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

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

Go to the documentation of this file.

/*
    This file is part of the Virtual Object System of
    the Interreality project (http://interreality.org).

    Copyright (C) 2001-2003 Peter Amstutz

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA

    Peter Amstutz <http://www.interreality.org>
*/

#ifndef _VOBJECTBASE_HH_
#define _VOBJECTBASE_HH_

/** @file
    Defines VobjectBase.
*/

#include <vos/vutil/refcount.hh>
#include <vos/vutil/url.hh>
#include <vos/vutil/log.hh>
#include <vos/vos/vobject.hh>
#include <vos/vutil/readwritemutex.hh>
#include <vos/vos/listener.hh>
#include <vos/vos/vobjectextension.hh>
#include <vos/vos/vobjectstate.hh>
#include <vos/vos/accesscontrolstate.hh>
#include <vos/vos/accesscontrol.hh>
#include <vos/vos/iterator.hh>
#include <vos/vos/policies.hh>

#include <deque>
#include <stdexcept>


namespace VOS
{
    class Site;
    class Message;
    class MessageBlock;
    class TypeChangeListener;
    class ParentChangeListener;
    class ChildChangeListener;
    class ParentChildRelation;
    class AccessControlList;
    class AccessControlState;
    class MetaObjectIterator;

    /** @class MessageDispatch vobjectbase.hh vos/vos/vobjectbase.hh
        @ingroup libvos
    */
    class VOS_API MessageDispatch
    {
    public:
        virtual ~MessageDispatch() {};
        virtual void sendMessage(Dispatchable* handler, Message* m) = 0;
    };

    template<class T> class MessageDispatchTemplate : public MessageDispatch
    {
    private:
        typedef void (T::* MessageHandler)(Message*);
        MessageHandler thismethod;

    public:
        MessageDispatchTemplate(MessageHandler themethod) : thismethod(themethod)
            { }

        virtual ~MessageDispatchTemplate() { }

        virtual void sendMessage(Dispatchable* mob, Message* m) {
            ((dynamic_cast<T*>(mob))->*thismethod)(m);
        }
    };

/** @class VobjectBase vobjectbase.hh vos/vos/vobjectbase.hh
    @ingroup libvos

    A base implementation class for virtual objects.  Except for a few
    implementation-specific added methods, the API is the same as
    Vobject.
*/
class VOS_API VobjectBase : public Vobject
{
private:
    bool islocal;
    bool exciseCalled;
    Site* site;

    std::string name;
    VUtil::URL url;

    boost::mutex flagstrings_mutex;
    std::set<std::string> flagstrings;

    VobjectState vobjectstate;

    typedef std::map<std::string, std::map<std::string, MessageDispatch*> > HandlerMap;

    static boost::mutex msghandlers_mutex;
    static HandlerMap msghandlers;

    static boost::mutex updatehandlers_mutex;
    static HandlerMap updatehandlers;

    VUtil::read_write_mutex metaobject_extensions_mutex;
    std::vector< std::pair<std::string, MetaObject*> > metaobject_extensions;

    VUtil::read_write_mutex vobject_extensions_mutex;
    std::vector< std::pair<std::string, VobjectExtension*> > vobject_extensions;

    AccessControlState* accesscontrolstate;

    VobjectBase(const std::string& name, Site* site, bool islocalobj);

protected:

    virtual void setURL(const VUtil::URL& u) { url = u; }

    virtual void msgSendImpl(boost::mutex& usehandlers_mutex, HandlerMap& usehandlers, Message* msg);

public:
    virtual ~VobjectBase();

    VobjectState& getVobjectState() { return vobjectstate; }

    virtual const std::string& getSiteName() const { return name; };
    virtual VUtil::vRef<Site> getSite() const;
    virtual const VUtil::URL& getURL() const { return url; }
    virtual bool isLocal() { return islocal; };
    virtual bool isRemote() { return (!islocal); };

#ifndef SWIG
    template<class T> static void addMessageHandler(const std::string& method,
                                                    void (T::* messageHandler)(Message*))
        {
            boost::mutex::scoped_lock lk(msghandlers_mutex);
            if (msghandlers[typeid(T).name()][method] != 0) {
                delete msghandlers[typeid(T).name()][method];
            }
            msghandlers[typeid(T).name()][method] = new MessageDispatchTemplate<T>(messageHandler);
        };

    template<class T> static void addUpdateHandler(const std::string& method,
                                                   void (T::* messageHandler)(Message*))
        {
            boost::mutex::scoped_lock lk(updatehandlers_mutex);
            if (updatehandlers[typeid(T).name()][method] != 0) {
                delete updatehandlers[typeid(T).name()][method];
            }
            updatehandlers[typeid(T).name()][method] = new MessageDispatchTemplate<T>(messageHandler);
        };

    template<class T> static void removeMessageHandler(const std::string& method)
        {
            boost::mutex::scoped_lock lk(msghandlers_mutex);

            HandlerMap::iterator i = msghandlers.find(typeid(T).name());

            if (i != msghandlers.end()) {
                std::map<std::string, MessageDispatch*>::iterator j = (*i).second.find(method);

                if (j != (*i).second.end()) {
                    delete (*j).second;
                    (*i).second.erase(j);
                }
            }
        };

    template<class T> static void removeUpdateHandler(const std::string& method)
        {
            boost::mutex::scoped_lock lk(updatehandlers_mutex);

            HandlerMap::iterator i = msghandlers.find(typeid(T).name());

            if (i != msghandlers.end()) {
                std::map<std::string, MessageDispatch*>::iterator j = (*i).second.find(method);

                if (j != (*i).second.end()) {
                    delete (*j).second;
                    (*i).second.erase(j);
                }
            }
        };
#endif

    /** Specify if this vobject's child list should be cached locally.
        Only meaningful for remote vobjects.  This means that we
        become a listener of the remote vobject child list and receive
        updates.  Calls to getChildren(), findChild() and findObject()
        will be serviced using the cached list and will not go out to
        the network.
        @param b If true, use cache.  If false, the list will not be
        cached (unless it is being listened to by another part of the
        program.)
     */
    virtual void cacheChildren(bool b);

    /** Specify if this vobject's parent set should be cached locally.
        Only meaningful for remote vobjects.  This means that we
        become a listener of the remote vobject parent set and receive
        updates.  Calls to getParents() and findParent() will be
        serviced using the cached set and will not go out to the
        network.
        @param b If true, use cache.  If false, the set will not be
        cached (unless it is being listened to by another part of the
        program.)
     */
    virtual void cacheParents(bool b);

    virtual TypeSetIterator getTypes(Vobject* requester);
    virtual TypeSetIterator getTypes()
        { return getTypes(0); }

    virtual void addType(Vobject* requester, const std::string& s);
    virtual void addType(const std::string& s)
        { addType(0, s); }

    virtual void removeType(Vobject* requester, const std::string& s);
    virtual void removeType(const std::string& s)
        { removeType(0, s); }

    virtual ParentSetIterator getParents(Vobject* requester);
    virtual ParentSetIterator getParents()
        { return getParents(0); }

        virtual ChildListIterator getChildren(Vobject* requester, int start = 0, int end = -1);
    virtual ChildListIterator getChildren(int start = 0, int end = -1)
        { return getChildren(0, start, end); }

        virtual int numChildren(Vobject* requester);
    virtual int numChildren()
        { return numChildren(0); }

    virtual VUtil::vRef<Vobject> findObject(Vobject* requester, const std::string& path);
    virtual VUtil::vRef<Vobject> findObject(const std::string& path)
                { return findObject(0, path); }

    virtual VUtil::vRef<ParentChildRelation> findChild(Vobject* requester, const std::string& path);
    virtual VUtil::vRef<ParentChildRelation> findChild(const std::string& path)
        { return findChild(0, path); }

    virtual VUtil::vRef<ParentChildRelation> findChild(Vobject* requester, int pos);
    virtual VUtil::vRef<ParentChildRelation> findChild(int pos)
        { return findChild(0, pos); }

    virtual VUtil::vRef<ParentChildRelation> findParent(Vobject* requester, Vobject& parent);
    virtual VUtil::vRef<ParentChildRelation> findParent(Vobject& parent)
        { return findParent(0, parent); }

    virtual VUtil::vRef<ParentChildRelation> findParent(Vobject* parent)
        { return findParent(0, *parent); }

    virtual void setChild(Vobject* requester,
                          int position, const std::string& contextual_name, Vobject* child);
    virtual void setChild(int position, const std::string& contextual_name, Vobject* child)
        { setChild(0, position, contextual_name, child); }

    virtual void insertChild(Vobject* requester,
                             int position, const std::string& contextual_name, Vobject* child);
    virtual void insertChild(int position, const std::string& contextual_name, Vobject* child)
        { insertChild(0, position, contextual_name, child); }

    virtual void removeChild(Vobject* requester, ParentChildRelation* pcr, bool strict = true);
    virtual void removeChild(ParentChildRelation* pcr, bool strict = true)
        { removeChild(0, pcr, strict); }

    virtual void sendMessage(Message* m);
    virtual void sendMessage(MessageBlock* m);
    virtual void sendUpdateMessage(Message* m);
#if 0
    virtual void initialize();
#endif

    virtual void addTypeListener(Vobject* requester, TypeChangeListener* tl, bool refresh = true);
    virtual void addTypeListener(TypeChangeListener* tl, bool refresh = true)
        { addTypeListener(0, tl, refresh); }

    virtual void addParentListener(Vobject* requester, ParentChangeListener* pl, bool refresh = true);
    virtual void addParentListener(ParentChangeListener* pl, bool refresh = true)
        { addParentListener(0, pl, refresh); }

    virtual void addChildListener(Vobject* requester, ChildChangeListener* cl, bool refresh = true);
    virtual void addChildListener(ChildChangeListener* cl, bool refresh = true)
        { addChildListener(0, cl, refresh); }

    virtual void removeTypeListener(Vobject* requester, TypeChangeListener* tl);
    virtual void removeTypeListener(TypeChangeListener* tl)
        { removeTypeListener(0, tl); }

    virtual void removeParentListener(Vobject* requester, ParentChangeListener* pl);
    virtual void removeParentListener(ParentChangeListener* pl)
        { removeParentListener(0, pl); }

    virtual void removeChildListener(Vobject* requester, ChildChangeListener* cl);
    virtual void removeChildListener(ChildChangeListener* cl)
        { removeChildListener(0, cl); }

    virtual void excise();

    virtual void saveState(MessageBlock& output, std::set<std::string>& types, bool portable);

    virtual void addFlag(const std::string& flag);
    virtual void removeFlag(const std::string& flag);
    virtual bool checkFlag(const std::string& flag);

    virtual void addVobjectExtension(VobjectExtension* vx);
    virtual void addMetaObjectExtension(MetaObject* m);

    virtual MetaObjectIterator getMetaObjectExtensions();

    virtual StringIterator getPolicy(Vobject* requester, const std::string& domain, Identity* id);
    virtual StringIterator getPolicy(const std::string& domain, Identity* id)
        { return getPolicy(0, domain, id); }

    virtual StringIterator getAvailablePolicies(Vobject* requester, const std::string& domain);
    virtual StringIterator getAvailablePolicies(const std::string& domain)
        { return getAvailablePolicies(0, domain); }

    virtual void addToACL(Vobject* requester, const std::string& ACLname, Identity* id);
    virtual void addToACL(const std::string& ACLname, Identity* id)
        { addToACL(0, ACLname, id); }

    virtual void addToACL(Vobject* requester, const std::string& ACLname, Group* grp);
    virtual void addToACL(const std::string& ACLname, Group* grp)
        { addToACL(0, ACLname, grp); }

    virtual void removeFromACL(Vobject* requester, const std::string& ACLname, Identity* id);
    virtual void removeFromACL(const std::string& ACLname, Identity* id)
        { removeFromACL(0, ACLname, id); }

    virtual void removeFromACL(Vobject* requester, const std::string& ACLname, Group* grp);
    virtual void removeFromACL(const std::string& ACLname, Group* grp)
        { removeFromACL(0, ACLname, grp); }

    virtual void deleteACL(Vobject* requester, const std::string& policies);
    virtual void deleteACL(const std::string& policies)
        { deleteACL(0, policies); }

    virtual std::string getDefaultPolicy(Vobject* requester, const std::string& domain);
    virtual std::string getDefaultPolicy(const std::string& domain = "")
        { return getDefaultPolicy(0, domain); }

    virtual void setDefaultPolicy(Vobject* requester, const std::string& policy);
    virtual void setDefaultPolicy(const std::string& policy)
        { setDefaultPolicy(0, policy); }

    virtual ACLIterator getAllACLs(Vobject* requester);
    virtual ACLIterator getAllACLs();


    void doAccessControlCheck(VobjectEvent& ve);

    template<class AccessControlType> inline std::vector<AccessControlType*>
                getAccessControlsFor(Vobject* requester,
                                PolicyDomain<AccessControlType>& accessControlPolicies);

    virtual VUtil::vRef<VobjectBase> getVobjectBase() { return VUtil::vRef<VobjectBase>(this, true); }

#ifndef SWIG
    template<class C> VUtil::vRef<C> queryInterface()
        {
            VUtil::scoped_read_lock lk(metaobject_extensions_mutex);
            for(std::vector< std::pair<std::string, MetaObject*> >::iterator i = metaobject_extensions.begin();
                i != metaobject_extensions.end();
                i++)
            {
                if(C* ret = dynamic_cast<C*>((*i).second)) return VUtil::vRef<C>(ret, true);
            }
            return VUtil::vRef<C>();
        }
    template<class C> C* queryExtension()
        {
            VUtil::scoped_read_lock lk(vobject_extensions_mutex);

            for(std::vector< std::pair<std::string, VobjectExtension*> >::iterator i = vobject_extensions.begin();
                i != vobject_extensions.end();
                i++)
            {
                if(C* ret = dynamic_cast<C*>((*i).second)) return ret;
            }
            return 0;
        }

    friend class Site;
#endif
};

    /** Copies the access control policies (default policy + access
        control lists) from one Vobject to another
    */
    VOS_API void copyAccessControlPolicies(Vobject* to, Vobject* from);

    /** @return true if the the supplied have the same access control
        lists (comparison does NOT include default policies).
    */
    VOS_API bool sameAccessControlLists(Vobject* a, Vobject* b);
}

#endif