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

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

Go to the documentation of this file.

#ifndef _VOBJECTSTORE_HH_
#define _VOBJECTSTORE_HH_

#include <vos/vos/vosdefs.hh>
#include <vos/vos/vobject.hh>
#include <vos/vos/site.hh>
#include <vos/vos/message.hh>
#include <vos/vos/vobjectstore.hh>
#include <vos/vutil/timer.hh>

namespace VOS {

/** @class VobjectStore vos/vos/vobjectstore.hh
 */
class VOS_API VobjectStore
{
public:
    /** An entry in the Vobject store table */
    struct Entry
    {
        Entry() { }
        Entry(const Entry& e)
            : vobject(e.vobject), types(e.types), mb(e.mb),
              pos(e.pos), savechildren(e.savechildren), blocks(e.blocks),
              acls(e.acls)
            { }

        ~Entry() {}

        /** The Vobject itself. */
        VUtil::vRef<Vobject> vobject;

        /** The type strings to save. */
        std::set<std::string> types;

        /** A list of messages which, when replayed, will restore the state
            of this Vobject. */
        VUtil::vRef<MessageBlock> mb;

        /** Used by remote CODs, the position of this object on the
            @em remote site. */
        int pos;

        /** Should this vobject's child table be written out? */
        bool savechildren;

        // The following two are used by data serialization formats
        // like XOD that use the persistance interface and save ACLs
        // explicitly rather than reconstructing the state via message
        // replays.

        /** Persistance data blocks */
        std::map<std::string, std::string> blocks;

        /** Access control lists */
        std::map< std::string, std::vector<std::string> > acls;
    };

    struct PCR
    {
        std::string context;
        std::string child;
    };

protected:
    VUtil::vRef<Site> ls;
    std::map<std::string, Entry*> vobjectTable;
    std::deque<Entry*> vobjectorder;

public:
    /** Constructor.
        @param ls The local site any new vobjects will be created on.
     */
    VobjectStore(Site& loadsite);

    VobjectStore(const VobjectStore& store);

    virtual ~VobjectStore();

    /** Add a Vobject to this store.
        @param v the Vobject
        @param portable passed to Vobject::saveState -- should this
        save site- or configuration-specific information (possibly
        making for a smaller file) or embed all necessary data?
        @param saveChildren should the child list be saved?
        @return the position of this entry in the vobject table
        @note This will use Vobject::saveState to get additional details
    */
    virtual int addVobject(Vobject* v, bool portable = true, bool saveChildren = true);

    /** Add a Vobject to this store.  This uses the supplied values,
        overriding the information stored in the Vobject itself.  It does not
        call Vobject::saveState()
        @param v the Vobject
        @param types the type strings to be saved
        @param mb a message block of messages used to restore the
        state of this Vobject
        @param saveChildren should the child list be saved?
        @return the position of this entry in the vobject table
    */
    virtual int addVobject(Vobject* v, const std::set<std::string>& types,
                           MessageBlock* mb, bool saveChildren);

    /** Add a Vobject to this store.  This uses the supplied values,
        overriding the information stored in the Vobject itself.  It does not
        call Vobject::saveState()
        @param v the Vobject
        @param types the type strings to be saved
        @param mb a message block of messages used to restore the
        state of this Vobject
        @param saveChildren should the child list be saved?
        @return the position of this entry in the vobject table
    */
    virtual int addVobject(Vobject* v, const std::deque<std::string>& types,
                           MessageBlock* mb, bool saveChildren);

    virtual int addVobject(Vobject* v, TypeSetIterator types,
                           MessageBlock* mb, bool saveChildren);

    /** Number of Vobjects in the Vobject table.
        @return the table size
    */
    virtual int numVobjects();

    /** Get the Vobject from the Vobject table by site name.
        @param name the site name
        @return the entry, or NULL if invalid
    */
    virtual Entry* getVobject(const std::string& name);

    /** Get the Vobject by position in the Vobject table.
        @param pos the position
        @return the entry, or NULL if invalid
     */
    virtual Entry* getVobject(int pos);

    /** Remove a Vobject from the Vobject table.
        @param name the site name
    */
    virtual void removeVobject(const std::string& name);

    /** Remove a Vobject from the Vobject table.
        @param pos the position in the Vobject table
    */
    virtual void removeVobject(int pos);

    /** Clear the Vobject table. */
    virtual void clear();

    /** Get the site that vobjects are to be added to if loading a
        vobject store from a file.  Has no effect on saving.
        @return the site
    */
    virtual VUtil::vRef<Site> getTargetSite();

    /** Merge the contents of a Vobject store into this one (must be on the same site).
        Vobjects are added with their site name.
        @param vs the store holding vobjects that are added to this store
     */
    virtual void addStore(VobjectStore* vs);
};

typedef std::map<std::string, void*> ImpExpEnv;

class VOS_API VobjectInput : public virtual VobjectStore
{
public:
    VobjectInput(Site& ls) : VobjectStore(ls) { }
    VobjectInput(const VobjectStore& v) : VobjectStore(v) { }
    virtual ~VobjectInput() { };

    /** Read a set of Vobjects from the initialized iostream */
    virtual void readVobjects(std::istream& input,
                              ImpExpEnv& environment) = 0;

    /** Read a set of Vobjects from the supplied data buffer.
        @param buffer the source data
        @param size the length of the data
    */
    virtual void readVobjects(unsigned char* buffer, unsigned int size,
                              ImpExpEnv& environment) = 0;

};

class VOS_API VobjectOutput : public virtual VobjectStore
{
public:
    VobjectOutput(Site& ls) : VobjectStore(ls) { }
    VobjectOutput(const VobjectStore& vs) : VobjectStore(vs) { }
    virtual ~VobjectOutput() { }

    /** Write a set of Vobjects to the supplied ostream.
    */
    virtual void writeVobjects(std::ostream& output,
                               ImpExpEnv& environment) = 0;

    /** Write a set of Vobjects to a buffer.  The buffer is malloc()'d
        and returned via the supplied parameters.
        @param buffer the data buffer holding the data.  You
        should free() this when you're done.
        @param size the size of the buffer
    */
    virtual void writeVobjects(unsigned char** buffer,
                               unsigned int* size,
                               ImpExpEnv& environment) = 0;
};

class VOS_API VobjectStoreLoader
{
public:
    virtual ~VobjectStoreLoader() { }

    virtual std::string getLoaderDescription() = 0;

    virtual bool isSupportedLoadFormat(unsigned char* buffer, unsigned int size) = 0;
    virtual bool isSupportedLoadFormat(std::istream& input) = 0;

    virtual VobjectStore* loadVobjects(Site& ls,
                                       unsigned char* buffer, unsigned int size,
                                       ImpExpEnv& environment) = 0;
    virtual VobjectStore* loadVobjects(Site& ls,
                                       std::istream& input,
                                       ImpExpEnv& environment) = 0;
};

class VOS_API VobjectStoreSaver
{
public:
    virtual ~VobjectStoreSaver() { }

    virtual std::string getFileExtension(const std::string& filetype) = 0;
    virtual bool isSupportedSaveFormat(const std::string& filetype) = 0;
    virtual std::string getSaverDescription() = 0;

    virtual void saveVobjects(VobjectStore* store,
                              const std::string& filetype,
                              unsigned char** buffer, unsigned int* size,
                              ImpExpEnv& environment) = 0;
    virtual void saveVobjects(VobjectStore* store,
                              const std::string& filetype,
                              std::ostream& output,
                              ImpExpEnv& environment) = 0;
};

class VOS_API UnsupportedFiletypeError : public std::runtime_error
{
public:
    UnsupportedFiletypeError(const std::string& s) : runtime_error(s) { };
};

class VOS_API FileAccessError : public std::runtime_error
{
public:
    FileAccessError(const std::string& s) : runtime_error(s) { };
};

class VOS_API VobjectImportExport
{
private:
    static std::vector<VobjectStoreLoader*>& loaders();
    static std::vector<VobjectStoreSaver*>& savers();

    VobjectImportExport() { }

public:
    static void addLoader(VobjectStoreLoader* l);
    static void addSaver(VobjectStoreSaver* s);

    static const std::vector<VobjectStoreLoader*>& getLoaders();
    static const std::vector<VobjectStoreSaver*>& getSavers();

    static VobjectStoreLoader* selectLoader(unsigned char* buffer, unsigned int size);
    static VobjectStoreLoader* selectLoader(std::istream& input);

    static VobjectStore* load(Site& ls, unsigned char* buffer, unsigned int size,
                              VobjectStoreLoader** l = 0);
    static VobjectStore* load(Site& ls, unsigned char* buffer, unsigned int size,
                              ImpExpEnv& environment,
                              VobjectStoreLoader** l = 0);


    static VobjectStore* load(Site& ls, std::istream& input,
                              VobjectStoreLoader** l = 0);
    static VobjectStore* load(Site& ls, std::istream& input,
                              ImpExpEnv& environment,
                              VobjectStoreLoader** l = 0);


    static VobjectStore* loadFile(Site& ls, const std::string& filename,
                                  VobjectStoreLoader** l = 0);
    static VobjectStore* loadFile(Site& ls, const std::string& filename,
                                  ImpExpEnv& environment,
                                  VobjectStoreLoader** l = 0);


    static VobjectStoreSaver* selectSaver(const std::string& filetype);

    static void save(VobjectStore* vs, const std::string& filetype,
                     unsigned char** buffer, unsigned int* size,
                     VobjectStoreSaver** s = 0);
    static void save(VobjectStore* vs, const std::string& filetype,
                     unsigned char** buffer, unsigned int* size,
                     ImpExpEnv& environment,
                     VobjectStoreSaver** s = 0);


    static void save(VobjectStore* vs, const std::string& filetype,
                     std::ostream& out,
                     VobjectStoreSaver** s = 0);
    static void save(VobjectStore* vs, const std::string& filetype,
                     std::ostream& out,
                     ImpExpEnv& environment,
                     VobjectStoreSaver** s = 0);


    static void saveFile(VobjectStore* vs,
                         const std::string& filetype,
                         const std::string& filename,
                         VobjectStoreSaver** s = 0);
    static void saveFile(VobjectStore* vs,
                         const std::string& filetype,
                         const std::string& filename,
                         ImpExpEnv& environment,
                         VobjectStoreSaver** s = 0);
};


}

#endif