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

/home/tetron/hack/vos/libs/vos/vos/metaobject.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 _METAOBJECT_HH_
#define _METAOBJECT_HH_

#include <stdexcept>
#include <typeinfo>

namespace VOS
{
#ifndef SWIG
    class MetaObject;
#endif
}

#include <vos/vos/vosdefs.hh>
#include <vos/vos/vobject.hh>

namespace VOS
{
#ifndef SWIG
    class VobjectBase;
#endif

/** @class MetaObject metaobject.hh vos/vos/metaobject.hh
    @ingroup libvos

    This class forwards every method in the Vobject API to the
    VobjectBase that it is attached to.  This is primarily useful for
    allowing subclasses of MetaObject to be usable as Vobjects in
    addition to adding their own API.  It also provides a couple of
    methods (VOS::MetaObject::doSaveState and VOS::MetaObject::doExcise)
    that can be overridden to provide custom behavior for those cases.
 */
class VOS_API MetaObject : public virtual Vobject, public Dispatchable
{
private:
    VobjectBase* superobject;
protected:
    MetaObject(VobjectBase* superobject);

    /** This is where you put type-handler specific save state code.
        @param output The messageblock to append your messages to
        @param types The types for the object that should be output as
        part of this save state. Some save state handlers may want to
        modify this.
        @param portable If true, generate a "portable" state.  This
        means that all the data required to restore state should be
        embedded in the message.  If false, fully recreating the state
        may rely on external resources such as files or databases.
        @see Vobject::saveState
    */
    virtual void doSaveState(MessageBlock& output, std::set<std::string>& types, bool portable);

    /** This is where you put type-handler specific code to respond to an excise().
        It will be called exactly once.
    */
    virtual void doExcise();
    virtual void doInitialize();

public:
    /** destructor */
    virtual ~MetaObject();

    /** @returns the specific VOS type name that represents the VOS
        interface this object is supplying.  This should always be
        overridden by the subclass.
    */
    virtual const std::string getVOSType();

    virtual const std::string& getSiteName() const;
    virtual VUtil::vRef<Site> getSite() const;
    virtual const VUtil::URL& getURL() const;
    virtual bool isLocal();
    virtual bool isRemote();
    virtual TypeSetIterator getTypes();
    virtual void addType(const std::string& s);
    virtual void removeType(const std::string& s);
    virtual ParentSetIterator getParents();
    virtual ChildListIterator getChildren(int start = 0, int end = -1);
    virtual int numChildren();

    virtual void sendMessage(Message* m);
    virtual void sendMessage(MessageBlock* m);
    virtual void sendUpdateMessage(Message* m);

    virtual VUtil::vRef<Vobject> findObject(const std::string& path);
    virtual VUtil::vRef<ParentChildRelation> findChild(const std::string& path);
    virtual VUtil::vRef<ParentChildRelation> findChild(int pos);
    virtual VUtil::vRef<ParentChildRelation> findParent(Vobject* parent);
    virtual void setChild(int position, const std::string& contextual_name, Vobject* child);
    virtual void insertChild(int position, const std::string& contextual_name, Vobject* child);
    virtual void removeChild(ParentChildRelation* pcr, bool strict = true);

    virtual void addTypeListener(TypeChangeListener* tl, bool refresh = true);
    virtual void addParentListener(ParentChangeListener* pl, bool refresh = true);
    virtual void addChildListener(ChildChangeListener* cl, bool refresh = true);
    virtual void removeTypeListener(TypeChangeListener* tl);
    virtual void removeParentListener(ParentChangeListener* pl);
    virtual void removeChildListener(ChildChangeListener* cl);

    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);

    /** @note Important: this is delegated to the top object, and
        means you want the entire logical Vobject to go away!  If
        called on an object with no superobject, it calls doExcise() on its type
        handlers.  Type implementation specific cleanup code (such as
        calling excise on certain children no longer needed) should
        override doExcise().
    */
    virtual void excise();

    /** Note that this is for the logical Vobject and not the specific
        MetaObject instance, i.e. it's forwarded to the VobjectBase
        just like everything else. */
    virtual void acquire();

    /** Note that this is for the logical Vobject and not the specific
        MetaObject instance, i.e. it's forwarded to the VobjectBase
        just like everything else. */
    virtual void release();

    /** Note that this is for the logical Vobject and not the specific
        MetaObject instance, i.e. it's forwarded to the VobjectBase
        just like everything else. */
    virtual int getRefCount();

    virtual VUtil::vRef<VobjectBase> getVobjectBase();

    virtual StringIterator getPolicy(const std::string& domain, Identity* id);
    StringIterator getAvailablePolicies(const std::string& domain);

    virtual void addToACL(const std::string& ACLname, Identity* id);
    virtual void addToACL(const std::string& ACLname, Group* grp);

    virtual void removeFromACL(const std::string& ACLname, Identity* id);
    virtual void removeFromACL(const std::string& ACLname, Group* grp);

    virtual void deleteACL(const std::string& policies);

    virtual std::string getDefaultPolicy(const std::string& domain = "");
    virtual void setDefaultPolicy(const std::string& policy);

    virtual ACLIterator getAllACLs();

    friend class VobjectBase;
};

}

#endif