[Home]	[About]
[Screenshots]	[Download]
[News]	[Community]
[Documentation]	[Manual]
[Bugs & Requests]	[Wiki]

/home/tetron/hack/vos/libs/vos/vos/identity.hh

Go to the documentation of this file.

#ifndef _IDENTITY_HH_
#define _IDENTITY_HH_

#include <vos/vos/metaobject.hh>
#include <vos/vos/site.hh>

#ifndef VOS_EXPORTS
IMPORT_METAOBJECT_FACTORIES(IdentityStuff)
#endif

namespace VOS {
        class IdentityChangeListener;
        class IdentityChanged;

    /** @class Identity identity.hh vos/vos/identity.hh
        @ingroup libvos

        Identity is the basic unit for determining access control.  By
        performing some authentication protocol (for example see
        LocalPasswordAuth and RemotePasswordAuth) a remote site may
        take on an Identity.  Once this is done, requests from the
        remote site will use that Identity in conjunction with a
        Vobject's access control lists to determine what access
        control policy to apply (see
        VOS::AccessControlState::getPolicy for details).
    */
    class VOS_API Identity : public MetaObject
    {
    private:
        Identity(VobjectBase* vb);
        VUtil::ListenerBase<IdentityChangeListener, IdentityChanged> listeners;

        friend class Site;

    public:
        /** Constructor used for metaobject factory.  Never call this directly. */
        static MetaObject* new_Identity(VobjectBase* vb, const std::string& type);

        /** @return "core:identity" */
        virtual const std::string getVOSType();

        /** Register a callback to be made when a remote site takes on
            this Identity.  This is only meaningful if this identity
            object is local!

            @param icl the IdentityChangeListener object to be called
         */
        void addListener (IdentityChangeListener *icl);
    };

    /** @class Group identity.hh vos/vos/identity.hh
        @ingroup libvos

        A Group of Identity objects.  This allows you to set access
        control policies that apply to a group of Identities rather
        than having to specify each Identity individually.  In
        general, Groups can be used to add capabilities, but not take
        them away, so you should design your permissions to start with
        restrictive defaults and then add permissions selectively via
        group membership.
    */
    class VOS_API Group : public MetaObject
    {
    private:
        Group(VobjectBase* vb);
    public:
        /** Constructor used for metaobject factory.  Never call this directly. */
        static MetaObject* new_Group(VobjectBase* vb, const std::string& type);

        /** @return "core:group" */
        virtual const std::string getVOSType();

        /** Convenience function to add an identity to this group.
            This method is equivilent to
            @code
            insertChild(-1, "core:member", id);
            @endcode
            @param id the identity to add to this group
         */
        virtual void addIdentity(Identity* id);
    };

    /** @class IdentityChangeListener identity.hh vos/vos/identity.hh
        @ingroup libvos
        Abstract interface for accepting identity change events.
    */
    class VOS_API IdentityChangeListener
    {
    public:
        /** Destructor */
        virtual ~IdentityChangeListener () { };

        /** Called to notify that remote site "peer" has taken
            on identity "id".
            @param id the identity that has been authenticated
            @param peer the remote site that has been granted the identity
        */
        virtual void notifyIdentityChange (Identity *id, Site *peer) = 0;
    };

    /** @class IdentityChanged identity.hh vos/vos/identity.hh
        @ingroup libvos
        This class stores information used by the notifyEventChanged
        listener event.
    */
    class VOS_API IdentityChanged : public VUtil::RefCounted
    {
    public:
        /** Constructor
            @param id the identity taken on by the peer
            @param peer a remote site that has just been granted the identity
         */
        IdentityChanged (Identity *id, Site *peer);

        /** Calls notifyIdentityChange on icl.  Used by the Listener
            template.
            @param icl the listener to call
         */
        void deliverTo (IdentityChangeListener *icl);

    private:
        VUtil::vRef<Identity> identity;
        VUtil::vRef<Site> peer;
    };
};


#endif