persist.h

Go to the documentation of this file.

// Copyright (C) 1999-2002 Open Source Telecom Corporation.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// This program 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 General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
// 
// As a special exception to the GNU General Public License, permission is 
// granted for additional uses of the text contained in its release 
// of Common C++.
// 
// The exception is that, if you link the Common C++ library with other
// files to produce an executable, this does not by itself cause the
// resulting executable to be covered by the GNU General Public License.
// Your use of that executable is in no way restricted on account of
// linking the Common C++ library code into it.
//
// This exception does not however invalidate any other reasons why
// the executable file might be covered by the GNU General Public License.
// 
// This exception applies only to the code released under the 
// name Common C++.  If you copy code from other releases into a copy of
// Common C++, as the General Public License permits, the exception does
// not apply to the code that you add in this way.  To avoid misleading
// anyone as to the status of such modified files, you must delete
// this exception notice from them.
// 
// If you write modifications of your own for Common C++, it is your choice
// whether to permit this exception to apply to your modifications.
// If you do not wish that, delete this exception notice.

#ifndef CCXX_PERSIST_H_
#define CCXX_PERSIST_H_

#ifndef CCXX_MISSING_H_
#include <cc++/missing.h>
#endif

#ifndef CCXX_STRING_H_
#include <cc++/string.h>
#endif

#ifdef HAVE_ZLIB_H
#ifndef NO_COMPRESSION
#include <zlib.h>
#endif
#else
#define NO_COMPRESSION
#endif

#include <iostream>
#include <string>
#include <vector>
#include <deque>
#include <map>

#ifdef CCXX_NAMESPACES
namespace ost {
#define NS_PREFIX ost::
#else
#define NS_PREFIX
#endif

#ifdef  CCXX_EXCEPTIONS
#ifdef  COMMON_STD_EXCEPTION

class __EXPORT PersistException : public Exception
{
public:
        PersistException(String what) : Exception(what) {};
};

#else

class PersistException
{
public:
        CCXX_MEMBER_EXPORT(CCXX_EMPTY) PersistException(const String& reason);
        CCXX_MEMBER_EXPORT(const String&) getString() const;
        CCXX_MEMBER_EXPORT(virtual) ~PersistException();
protected:
        String _what;
};

#endif
#endif

// This typedef allows us to declare NewBaseObjectFunction now
typedef class BaseObject* (*NewBaseObjectFunction) (void);

class TypeManager
{
public:
        
        class Registration
        {
        public:
                Registration(const char* name, NewBaseObjectFunction func)
                        : myName(name) { TypeManager::add(name,func); }
                virtual ~Registration() { TypeManager::remove(myName.c_str()); }
        private:
                String myName;
        };
        
        CCXX_MEMBER_EXPORT(static void) add(const char* name, NewBaseObjectFunction construction);
        
        CCXX_MEMBER_EXPORT(static void) remove(const char* name);
        
        CCXX_EXPORT(static BaseObject*) createInstanceOf(const char* name);
        
        typedef std::map<String,NewBaseObjectFunction> StringFunctionMap;
};


/*
 * The following defines are used to declare and define the relevant code
 * to allow a class to use the Persistence::Engine code.
 */

#define DECLARE_PERSISTENCE(ClassType)                                  \
  public:                                                               \
    friend NS_PREFIX Engine& operator>>( NS_PREFIX Engine& ar, ClassType *&ob);         \
    friend NS_PREFIX Engine& operator<<( NS_PREFIX Engine& ar, ClassType const &ob);    \
    friend NS_PREFIX BaseObject *createNew##ClassType();                                \
    virtual const char* getPersistenceID() const;                       \
    static NS_PREFIX TypeManager::Registration registrationFor##ClassType;

#define IMPLEMENT_PERSISTENCE(ClassType, FullyQualifiedName)                  \
  NS_PREFIX BaseObject *createNew##ClassType() { return new ClassType; }                      \
  const char* ClassType::getPersistenceID() const {return FullyQualifiedName;} \
  NS_PREFIX Engine& operator>>(NS_PREFIX Engine& ar, ClassType &ob)                           \
    { ar >> (NS_PREFIX BaseObject &) ob; return ar; }                                 \
  NS_PREFIX Engine& operator>>(NS_PREFIX Engine& ar, ClassType *&ob)                          \
    { ar >> (NS_PREFIX BaseObject *&) ob; return ar; }                                \
  NS_PREFIX Engine& operator<<(NS_PREFIX Engine& ar, ClassType const &ob)                             \
    { ar << (NS_PREFIX BaseObject const *)&ob; return ar; }                           \
  NS_PREFIX TypeManager::Registration                                                 \
        ClassType::registrationFor##ClassType(FullyQualifiedName,             \
                                              createNew##ClassType);

class Engine;

class BaseObject
{
public:
        CCXX_MEMBER_EXPORT(CCXX_EMPTY) BaseObject();
        
        CCXX_MEMBER_EXPORT(virtual) ~BaseObject();
        
        CCXX_MEMBER_EXPORT(virtual const char*) getPersistenceID() const;
        
        CCXX_MEMBER_EXPORT(virtual bool) write(Engine& archive) const;

        CCXX_MEMBER_EXPORT(virtual bool) read(Engine& archive);
};


class Engine
{
public:
#ifdef  CCXX_EXCEPTIONS
        class Exception : public PersistException
        {
        public:
                CCXX_MEMBER_EXPORT(CCXX_EMPTY) Exception(const String &reason);
        };
#endif
        
        enum EngineMode
        {
                modeRead,
                modeWrite
        };
        
        CCXX_MEMBER_EXPORT(CCXX_EMPTY) Engine(std::iostream& stream, EngineMode mode) THROWS (PersistException);
        
        CCXX_MEMBER_EXPORT(virtual) ~Engine();


        // Write operations

        CCXX_MEMBER_EXPORT(void) write(const BaseObject &object) THROWS (Exception)
  { write(&object); };

        CCXX_MEMBER_EXPORT(void) write(const BaseObject *object) THROWS (Exception);

        // writes supported primitive types
  // shortcut, to make the following more readable
#define CCXX_ENGINEWRITE_REF(valref) writeBinary((const uint8*)&valref,sizeof(valref))
        void write(int8 i)   THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
        void write(uint8 i)  THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
        void write(int16 i)  THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
        void write(uint16 i) THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
        void write(int32 i)  THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
        void write(uint32 i) THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
#ifdef  HAVE_64_BITS
        void write(int64 i)  THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
        void write(uint64 i) THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
#endif
        void write(float i)  THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
        void write(double i) THROWS (Exception) { CCXX_ENGINEWRITE_REF(i); }
#undef CCXX_ENGINEWRITE_REF
        CCXX_MEMBER_EXPORT(void) write(const String& str) THROWS (Exception);

        // Every write operation boils down to one or more of these
        CCXX_MEMBER_EXPORT(void) writeBinary(const uint8* data, const uint32 size) THROWS (Exception);


        // Read Operations

        CCXX_MEMBER_EXPORT(void) read(BaseObject &object) THROWS (Exception);

        CCXX_MEMBER_EXPORT(void) read(BaseObject *&object) THROWS (Exception);

        // reads supported primitive types
  // shortcut, to make the following more readable
#define CCXX_ENGINEREAD_REF(valref) readBinary((uint8*)&valref,sizeof(valref))
        void read(int8& i)   THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
        void read(uint8& i)  THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
        void read(int16& i)  THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
        void read(uint16& i) THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
        void read(int32& i)  THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
        void read(uint32& i) THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
#ifdef  HAVE_64_BITS
        void read(int64& i)  THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
        void read(uint64& i) THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
#endif
        void read(float& i)  THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
        void read(double& i) THROWS (Exception) { CCXX_ENGINEREAD_REF(i); }
#undef CCXX_ENGINEREAD_REF

        CCXX_MEMBER_EXPORT(void) read(String& str) THROWS (Exception);

        // Every read operation boild down to one or more of these
        CCXX_MEMBER_EXPORT(void) readBinary(uint8* data, uint32 size) THROWS (Exception);

private:
  void readObject(BaseObject* object);

  const String readClass();


        std::iostream& myUnderlyingStream;
        
        EngineMode myOperationalMode;

        typedef std::vector<BaseObject*>           ArchiveVector;
        typedef std::map<BaseObject const*, int32> ArchiveMap;
        typedef std::vector<String>                ClassVector;
        typedef std::map<String, int32>            ClassMap;
        
        ArchiveVector myArchiveVector;
        ArchiveMap myArchiveMap;
        ClassVector myClassVector;
        ClassMap myClassMap;

        // Compression support
#ifndef NO_COMPRESSION
        z_stream myZStream;
        uint8* myCompressedDataBuffer;
        uint8* myUncompressedDataBuffer;
        uint8* myLastUncompressedDataRead;
#endif
};

// Standard >> and << stream operators for BaseObject
CCXX_EXPORT(Engine&) operator >>( Engine& ar, BaseObject &ob)      THROWS (Engine::Exception);
CCXX_EXPORT(Engine&) operator >>( Engine& ar, BaseObject *&ob)      THROWS (Engine::Exception);
CCXX_EXPORT(Engine&) operator <<( Engine& ar, BaseObject const &ob) THROWS (Engine::Exception);
CCXX_EXPORT(Engine&) operator <<( Engine& ar, BaseObject const *ob) THROWS (Engine::Exception);

CCXX_EXPORT(Engine&) operator >>( Engine& ar, int8& ob) THROWS (Engine::Exception);
CCXX_EXPORT(Engine&) operator <<( Engine& ar, int8 ob)  THROWS (Engine::Exception);

CCXX_EXPORT(Engine&) operator >>( Engine& ar, uint8& ob) THROWS (Engine::Exception);
CCXX_EXPORT(Engine&) operator <<( Engine& ar, uint8 ob)  THROWS (Engine::Exception);

CCXX_EXPORT(Engine&) operator >>( Engine& ar, int16& ob) THROWS (Engine::Exception);
CCXX_EXPORT(Engine&) operator <<( Engine& ar, int16 ob)  THROWS (Engine::Exception);

CCXX_EXPORT(Engine&) operator >>( Engine& ar, uint16& ob) THROWS (Engine::Exception);
CCXX_EXPORT(Engine&) operator <<( Engine& ar, uint16 ob)  THROWS (Engine::Exception);

CCXX_EXPORT(Engine&) operator >>( Engine& ar, int32& ob) THROWS (Engine::Exception);
CCXX_EXPORT(Engine&) operator <<( Engine& ar, int32 ob)  THROWS (Engine::Exception);

CCXX_EXPORT(Engine&) operator >>( Engine& ar, uint32& ob) THROWS (Engine::Exception);
CCXX_EXPORT(Engine&) operator <<( Engine& ar, uint32 ob)  THROWS (Engine::Exception);

#ifdef  HAVE_64_BITS

CCXX_EXPORT(Engine&) operator >>( Engine& ar, int64& ob) THROWS (Engine::Exception);
CCXX_EXPORT(Engine&) operator <<( Engine& ar, int64 ob)  THROWS (Engine::Exception);

CCXX_EXPORT(Engine&) operator >>( Engine& ar, uint64& ob) THROWS (Engine::Exception);
CCXX_EXPORT(Engine&) operator <<( Engine& ar, uint64 ob)  THROWS (Engine::Exception);
#endif

CCXX_EXPORT(Engine&) operator >>( Engine& ar, float& ob) THROWS (Engine::Exception);
CCXX_EXPORT(Engine&) operator <<( Engine& ar, float ob)  THROWS (Engine::Exception);

CCXX_EXPORT(Engine&) operator >>( Engine& ar, double& ob) THROWS (Engine::Exception);
CCXX_EXPORT(Engine&) operator <<( Engine& ar, double ob)  THROWS (Engine::Exception);

CCXX_EXPORT(Engine&) operator >>( Engine& ar, String& ob) THROWS (Engine::Exception);
CCXX_EXPORT(Engine&) operator <<( Engine& ar, String ob)  THROWS (Engine::Exception);

CCXX_EXPORT(Engine&) operator >>( Engine& ar, bool& ob) THROWS (Engine::Exception);
CCXX_EXPORT(Engine&) operator <<( Engine& ar, bool ob)  THROWS (Engine::Exception);

template<class T>
Engine& operator <<( Engine& ar, typename std::vector<T> const& ob) THROWS (Engine::Exception)
{
        ar << (uint32)ob.size();
        for(uint i=0; i < ob.size(); ++i)
                ar << ob[i];
        return ar;
}

template<class T>
Engine& operator >>( Engine& ar, typename std::vector<T>& ob) THROWS (Engine::Exception)
{
        ob.clear();
        uint32 siz;
        ar >> siz;
        ob.resize(siz);
        for(uint32 i=0; i < siz; ++i)
                ar >> ob[i];
        return ar;
}

template<class T>
Engine& operator <<( Engine& ar, typename std::deque<T> const& ob) THROWS (Engine::Exception)
{
        ar << (uint32)ob.size();
  for(typename std::deque<T>::const_iterator it=ob.begin(); it != ob.end(); ++it)
                ar << *it;
        return ar;
}

template<class T>
Engine& operator >>( Engine& ar, typename std::deque<T>& ob) THROWS (Engine::Exception)
{
        ob.clear();
        uint32 siz;
        ar >> siz;
        //ob.resize(siz);
        for(uint32 i=0; i < siz; ++i)
  {
    T node;
    ar >> node;
    ob.push_back(node);
                //ar >> ob[i];
  }
        return ar;
}

template<class Key, class Value>
Engine& operator <<( Engine& ar, typename std::map<Key,Value> const & ob) THROWS (Engine::Exception)
{
        ar << (uint32)ob.size();
        for(typename std::map<Key,Value>::const_iterator it = ob.begin();it != ob.end();++it)
                ar << it->first << it->second;
        return ar;
}

template<class Key, class Value>
Engine& operator >>( Engine& ar, typename std::map<Key,Value>& ob) THROWS (Engine::Exception)
{
        ob.clear();
        uint32 siz;
        ar >> siz;
        for(uint32 i=0; i < siz; ++i) {
                Key a;
                ar >> a;
                ar >> ob[a];
        }
        return ar;
}

#ifdef  CCXX_NAMESPACES
};
#endif

#endif

---