persistenceManager.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_CONCEPT_PERSISTENCEMANAGER_H
#define BALL_CONCEPT_PERSISTENCEMANAGER_H

#ifndef BALL_COMMON_RTTI_H
# include <BALL/COMMON/rtti.h>
#endif

#ifndef BALL_DATATYPE_HASHMAP_H
# include <BALL/DATATYPE/hashMap.h>
#endif

#ifndef BALL_DATATYPE_STRINGHASHMAP_H
# include <BALL/DATATYPE/stringHashMap.h>
#endif

#ifndef BALL_DATATYPE_HASHSET_H
# include <BALL/DATATYPE/hashSet.h>
#endif

#ifndef BALL_CONCEPT_PERSISTENTOBJECT_H
# include <BALL/CONCEPT/persistentObject.h>
#endif

#ifndef BALL_COMMON_GLOBAL_H
# include <BALL/COMMON/global.h>
#endif

#include <fstream>
#include <iomanip>

#include <boost/shared_ptr.hpp>

#define BALL_WRITE_PRIMITIVE_MEMBER(pm,x) pm.writePrimitive(x,#x)
#define BALL_READ_PRIMITIVE_MEMBER(pm,x) pm.readPrimitive(x,#x)

namespace BALL 
{

  class BALL_EXPORT PersistenceManager
  {
    public:

      
    typedef void * (*CreateMethod) ();


    PersistenceManager();

    PersistenceManager(const PersistenceManager& pm);

    PersistenceManager(::std::istream& is);
      
    PersistenceManager(::std::ostream& os);
      
    PersistenceManager(::std::istream& is, ::std::ostream& os);
      
    virtual ~PersistenceManager();



    virtual void registerClass(String signature, const CreateMethod m);

    virtual void* createObject(String signature) const;

    virtual Size  getNumberOfClasses() const;
    
    virtual void setOstream(::std::ostream& s);

    virtual void setIstream(::std::istream& s);

    void startOutput();

    void endOutput();

    PersistentObject* readObject();

    PersistenceManager& operator << (const PersistentObject& object);

    PersistenceManager& operator >> (PersistentObject*& object_ptr);



    template <typename T>
    bool checkObjectHeader(const T& /* object */, const char* name = 0);

    bool checkObjectHeader(const char* type_name);

    template <typename T>
    void writeObjectHeader(const T* object, const char* name = 0);

    void writeObjectTrailer(const char* name = 0);

    bool checkObjectTrailer(const char* name = 0);

    template <typename T>
    void writePrimitive(const T& t, const char* name); 

    template <typename T>
    bool readPrimitive(T& t, const char* name);

    template <typename T>
    void writeStorableObject(const T& t, const char* name);

    template <typename T>
    bool readStorableObject(T& t, const char* name);

    template <typename T>
    void writeObjectPointer(const T* object, const char* name);
 
    template <typename T>
    bool readObjectPointer(T*& object, const char* name);

    template <typename T>
    bool readObjectSmartPointer(boost::shared_ptr<T>& s_ptr, const char* name);

    template <typename T>
    void writeObjectReference(const T& object, const char* name);

    template <typename T>
    bool readObjectReference(T& object, const char* name);

    template <typename T>
    void writeObjectArray(const T* array, const char* name, Size size);

    template <typename T>
    bool readObjectArray(const T* array, const char* name, Size& size);

    template <typename T>
    void writeObjectPointerArray(T** arr, const char* name, const Size size);
  
    template <typename T>
    bool readObjectPointerArray(T** array, const char* name, Size& size);
   

      
    virtual void writeHeader(const char* type_name, const char* name,
        LongSize ptr) = 0;

    virtual bool checkHeader(const char* type_name, const char* name,
        LongSize& ptr) = 0;

    virtual void writeTrailer(const char* name = 0) = 0;

    virtual bool checkTrailer(const char* name = 0) = 0;


    virtual void writeStreamHeader() = 0;


    virtual void writeStreamTrailer() = 0;


    virtual bool checkStreamHeader() = 0;


    virtual bool checkStreamTrailer() = 0;


    virtual bool getObjectHeader(String& type_name, LongSize& ptr) = 0;


    virtual void writeName(const char* name) = 0;


    virtual bool checkName(const char* name) = 0;


    virtual void writeStorableHeader(const char* type_name,
        const char* name) = 0;
      
    virtual bool checkStorableHeader(const char* type_name,
        const char* name) = 0;

    virtual void writeStorableTrailer() = 0;


    virtual bool checkStorableTrailer() = 0;


    virtual void writePrimitiveHeader(const char* type_name,
        const char* name) = 0;

    virtual bool checkPrimitiveHeader(const char* type_name,
        const char* name) = 0;

    virtual void writePrimitiveTrailer() = 0;


    virtual bool checkPrimitiveTrailer() = 0;


    virtual void writeObjectPointerHeader(const char* type_name,
        const char* name) = 0;


    virtual bool checkObjectPointerHeader(const char* type_name,
        const char* name) = 0;


    virtual void writeObjectReferenceHeader(const char* type_name,
        const char* name) = 0;


    virtual bool checkObjectReferenceHeader(const char* type_name,
        const char* name) = 0;


    virtual void writeObjectPointerArrayHeader(const char* type_name,
        const char* name, Size size) = 0;


    virtual bool checkObjectPointerArrayHeader(const char* type_name,
        const char* name, Size& size) = 0;


    virtual void writeObjectPointerArrayTrailer() = 0;


    virtual bool checkObjectPointerArrayTrailer() = 0;


    virtual void initializeOutputStream();


    virtual void finalizeOutputStream();


    virtual void initializeInputStream();


    virtual void finalizeInputStream();


    
    virtual void put(const char c) = 0;

    virtual void put(const Byte c) = 0;

    virtual void put(const Index i) = 0;

    virtual void put(const Size p) = 0;

    virtual void put(const bool b) = 0;

    virtual void put(const Real f) = 0;

    virtual void put(const DoubleReal d) = 0;

    virtual void put(const string& s) = 0;

    virtual void put(const LongSize p) = 0;



    virtual void get(char& c) = 0;

    virtual void get(Byte& b) = 0;

    virtual void get(Index& s) = 0;

    virtual void get(Size& s) = 0;

    virtual void get(bool& b) = 0;

    virtual void get(Real& f) = 0;

    virtual void get(DoubleReal& d) = 0;

    virtual void get(string& s) = 0;

    virtual void get(LongSize& p) = 0;


    protected:

    /*_ Register all BALL kernel classes.
        This method is automatically called in the constructor.
    */
    void registerKernelClasses_();

    /*_
    */
    void addPointerPair_(LongSize old_ptr, void* new_ptr);
        
    /*_
     * \throws Exception::GeneralException
    */
    void addNeededObjects_();

    /*_
    */
    bool updatePointers_();

    /*_
    */
    typedef HashSet<const PersistentObject*>      ObjectSet;
    
    /*_
    */
    typedef std::list<const PersistentObject*>    ObjectList;
    
    /*_
    */
    typedef HashMap<LongSize, void*>        PointerMap;
    
    /*_
    */
    typedef std::list<std::pair<void**, LongSize> >   PointerList;

    /*_
    */
    typedef std::list<std::pair<boost::shared_ptr<PersistentObject>*, LongSize> > SmartPointerList;

    /*_
    */
    StringHashMap<CreateMethod>   create_methods_;

    /*_ a hash set containing the pointers of the 
        objects that were already written
    */
    ObjectSet   object_out_;

    /*_ a list of object pointers that were referenced
        by objects already written, but have not yet
        been written themselves
    */
    ObjectList  object_out_needed_;

    /*_ a map relating the pointers read from the stream (LongSize)
        with the pointers of the persistent objects that were created
        dynamically
    */
    PointerMap  pointer_map_;
    
    //_
    PointerList pointer_list_;

    //_
    SmartPointerList smart_pointer_list_;

    //_
    ObjectList  object_in_;

    //_
    ::std::ostream* ostr_;
    //_
    ::std::istream* istr_;
  };


  // implementation of templated methods
  
  template <typename T>
  bool PersistenceManager::checkObjectHeader(const T& /* object */,
      const char* name)
  {
    LongSize ptr;
    return checkHeader(RTTI::getStreamName<T>(), name, ptr);
  }


  template <typename T>
  void PersistenceManager::writeObjectHeader(const T* object,
      const char* name)
  {
    object_out_.insert(object);
    writeHeader(RTTI::getStreamName<T>(), name, (LongSize)reinterpret_cast<PointerSizeUInt>(object));
  }


  template <typename T>
  void PersistenceManager::writePrimitive(const T& t, const char* name)
  {
    writePrimitiveHeader(RTTI::getStreamName<T>(), name);
    put(t);
    writePrimitiveTrailer();
  }


  template <typename T>
  bool PersistenceManager::readPrimitive(T& t, const char* name)
  {
    if (!checkPrimitiveHeader(RTTI::getStreamName<T>(), name))
    {
      return false;
    }

    get(t);
    return checkPrimitiveTrailer();
  }


  template <typename T>
  void PersistenceManager::writeStorableObject(const T& t, const char* name)
  {
    writeStorableHeader(RTTI::getStreamName<T>(), name);
    t.write(*this);
    writeStorableTrailer();
  }


  template <typename T>
  bool PersistenceManager::readStorableObject(T& t, const char* name)
  {
    return (checkStorableHeader(RTTI::getStreamName<T>(), name) 
            && t.read(*this) && checkStorableTrailer());
  }


  template <typename T>
  void PersistenceManager::writeObjectPointer(const T* object, const char* name)
  {
    if (object != 0 && !object_out_.has(object))
    {
      object_out_needed_.push_back(object);
    }

    writeObjectPointerHeader(RTTI::getStreamName<T>(), name);
    put(static_cast<LongSize>(reinterpret_cast<PointerSizeUInt>(object)));
    writePrimitiveTrailer();
  }


  template <typename T>
  bool PersistenceManager::readObjectPointer(T*& object, const char* name)
  {
    if (!checkObjectPointerHeader(RTTI::getStreamName<T>(), name))
    {
      return false;
    }

    LongSize ptr;
    get(ptr);

    if (ptr != 0)
    {
      pointer_list_.push_back(std::make_pair((void**)&object, ptr));
    }

    object = reinterpret_cast<T*>(static_cast<PointerSizeUInt>(ptr));

    return checkPrimitiveTrailer();
  } 

  template <typename T>
  bool PersistenceManager::readObjectSmartPointer(boost::shared_ptr<T>& s_ptr, const char* name)
  {
    if (!checkObjectPointerHeader(RTTI::getStreamName<T>(), name))
    {
      return false;
    }

    LongSize ptr;
    get(ptr);

    if (ptr != 0)
    {
      smart_pointer_list_.push_back(std::make_pair((boost::shared_ptr<PersistentObject>*)&s_ptr, (LongSize)((PersistentObject*)ptr)));
    }

    return checkPrimitiveTrailer();
  } 

  template <typename T>
  void PersistenceManager::writeObjectReference(const T& object,
      const char* name)
  {
    if (&object != 0 && !object_out_.has(&object))
    {
      object_out_needed_.push_back(&object);
    }

    writeObjectReferenceHeader(RTTI::getStreamName<T>(), name);
    put((LongSize)(void*)&object);
    writePrimitiveTrailer();
  } 


  template <typename T>
  bool PersistenceManager::readObjectReference(T& object, const char* name)
  {
    if (!checkObjectReferenceHeader(RTTI::getStreamName<T>(), name))
    {
      return false;
    }

    LongSize ptr;
    get(ptr);

    // store a zero in the corresponding pointer
    // since we cannot convert 64 bit pointers to
    // 32 bit pointers - this is required, if an object
    // written on a 64 bit architecture is read on a 32 bit
    // machine
    object = 0;

    if (ptr != 0)
    {
      pointer_list_.push_back(std::make_pair((void**)&object, ptr));
    }

    return checkPrimitiveTrailer();
  }

  template <typename T>
  void PersistenceManager::writeObjectArray(const T* array, const char* name,
      Size size)
  {
    writeObjectPointerArrayHeader(RTTI::getStreamName<T>(), name, size);

    for (Position i = 0; i < size; i++)
    {
      (*this) << array[i];
    }

    writeObjectPointerArrayTrailer();
  }

  template <typename T>
  bool PersistenceManager::readObjectArray
    (const T* array, const char* name, Size& size)
  {
    if (!checkObjectPointerArrayHeader(RTTI::getStreamName<T>(), name, size))
    {
      return false;
    }

    T* ptr = const_cast<T*>(array);
    for (Position i = 0; i < size; i++) 
    {
      (*this) >> ptr[i];
    }

    bool result = checkObjectPointerArrayTrailer();
    return result;
  } 

  template <typename T>
  void PersistenceManager::writeObjectPointerArray
    (T** arr, const char* name, const Size size)
  {
    writeObjectPointerArrayHeader(RTTI::getStreamName<T>(), name, size);

    PersistentObject* ptr;
    for (Position i = 0; i < size; i++)
    {
      ptr = (PersistentObject*)arr[i];
      put(static_cast<LongSize>(reinterpret_cast<PointerSizeUInt>(ptr)));
      if (ptr != 0 && !object_out_.has(ptr))
      {
        object_out_needed_.push_back(ptr);
      }
    }
    
    writeObjectPointerArrayTrailer();
  }


  template <typename T>
  bool PersistenceManager::readObjectPointerArray(T** array, const char* name,
      Size& size)
  {
    if (!checkObjectPointerArrayHeader(RTTI::getStreamName<T>(), name, size))
    {
      return false;
    }

    LongSize ptr;
    for (Position i = 0; i < size; i++) 
    {
      get(ptr);

      if (ptr != 0)
      {
        pointer_list_.push_back(std::make_pair((void**)&(array[i]), ptr));
      }

      array[i] = reinterpret_cast<T*>(static_cast<PointerSizeUInt>(ptr));
    }

    return checkObjectPointerArrayTrailer();
  }

#ifndef BALL_NO_INLINE_FUNCTIONS
# include <BALL/CONCEPT/persistenceManager.iC>
#endif

} // namespace BALL

#endif // BALL_CONCEPT_PERSISTENCEMANAGER_H