TPZSavable.h

Go to the documentation of this file.

#ifndef TPZSAVABLE_H
#define TPZSAVABLE_H

#include <string>     // for string
#include <set>        // for std::set
#include <map>        // for std::map
#include <utility>    // for pair
#include "pzerror.h"  // for DebugStop
#include "pzvec.h"    // for TPZVec
#include <list>       // for std::list
class TPZSavable;  // lines 20-20
class TPZStream;  // lines 21-21
class TPZRestoreClassBase;
class TPZChunkTranslator;
const int TPZSAVEABLEID = -1;

typedef TPZRestoreClassBase * TPZRestore_t;


//#define DEBUG_SAVEABLE

#ifdef PZDEBUG_SAVEABLE
#define SAVEABLE_STR_NOTE(buf,str) { std::string msg(str); buf.Write(&msg,1); }
#define SAVEABLE_SKIP_NOTE(buf) { std::string str; buf.Read(&str,1); }
#else
#define SAVEABLE_STR_NOTE(buf,str)
#define SAVEABLE_SKIP_NOTE(buf)
#endif


//Change the default constructor of TPZRegisterClassId to
// TPZRegisterClassId() = delete;
// in order to check all TPZSavable children classes for ClassId()
class TPZRegisterClassId {
public:
    // this matches the signature of 'ClassId() const'
    template <typename T>
    TPZRegisterClassId(int (T::*)() const) {
    }
    TPZRegisterClassId() = default;
};

class TPZSavable : public virtual TPZRegisterClassId {
                
public :
                static std::set<TPZRestoreClassBase*> &RestoreClassSet() {
                                static std::set<TPZRestoreClassBase*> gRestoreClassSet;
                                return gRestoreClassSet;
                }
        
                static std::map<int,TPZRestore_t> &ClassIdMap() {
                                static std::map<int,TPZRestore_t> gClassIdMap;
                                return gClassIdMap;
                }
                
                
public:
                
    TPZSavable() : TPZRegisterClassId(&TPZSavable::ClassId) { } 
                virtual ~TPZSavable()
                {
                }
                
                public:
virtual int ClassId() const = 0;

        
                virtual std::list<std::map<std::string, uint64_t>> VersionHistory() const;
                virtual std::pair<std::string, uint64_t> Version() const;
    
    static std::pair<std::string, uint64_t> NeoPZVersion();
                
                //virtual void Write(TPZStream &buf, int withclassid) const;
                
                virtual void Write(TPZStream &buf, int withclassid) const;
                
                virtual void Read(TPZStream &buf, void *context);
                
                virtual bool Compare(TPZSavable *copy, bool override = false);
                
                virtual bool Compare(TPZSavable *copy, bool override = false) const;

        static void Register(TPZRestoreClassBase *restore);
                
        static void RegisterClassId(int classid, TPZRestore_t fun);
                
        static TPZSavable *CreateInstance(const int &classId);
};


class TPZRestoreClassBase{
public :
    virtual TPZSavable *Restore()=0;
    virtual TPZChunkTranslator *GetTranslator()=0;
};

template<class T>
class TPZRestoreClass : public TPZRestoreClassBase {
public:

    TPZRestoreClass() {
        TPZSavable::Register(this);
    }

    virtual TPZSavable *Restore() {
        T *ptr = new T;
        return ptr;
    }
    
    virtual TPZChunkTranslator *GetTranslator() {
        return nullptr;
    }
    
private:
    static TPZRestoreClass<T> gRestoreObject;
};

template<class T>
TPZRestoreClass<T> TPZRestoreClass<T>::gRestoreObject;


template<class T, class TranslatorType>
class TPZRestoreClassWithTranslator : public TPZRestoreClassBase {
public:

    TPZRestoreClassWithTranslator() {
        TPZSavable::Register(this);
    }
    
    ~TPZRestoreClassWithTranslator();

    virtual TPZSavable *Restore() {
        T *ptr = new T;
        return ptr;
    }
    
    virtual TPZChunkTranslator *GetTranslator() {
        if (!gTranslator){
            gTranslator = new TranslatorType();
        }
        return gTranslator;
    }
    
private:
    static TPZRestoreClassWithTranslator<T,TranslatorType> gRestoreObject;
    static TPZChunkTranslator *gTranslator;
};

#include "TPZChunkTranslator.h"
template<class T, class TranslatorType>
TPZRestoreClassWithTranslator<T, TranslatorType>::~TPZRestoreClassWithTranslator() {
    if (gTranslator) {
        delete gTranslator;
    }
}

template<class T, class TranslatorType>
TPZRestoreClassWithTranslator<T,TranslatorType> TPZRestoreClassWithTranslator<T,TranslatorType>::gRestoreObject;

template<class T, class TranslatorType>
TPZChunkTranslator *TPZRestoreClassWithTranslator<T,TranslatorType>::gTranslator = NULL;

#endif //TPZSAVABLE_H