gmStateDumpItem.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE.
**
************************************************************************/
 
#ifndef _GEMA_STATE_DUMP_ITEM_H_
#define _GEMA_STATE_DUMP_ITEM_H_
 
#include "gmMemoryDump.h"
 
#include "gmVector.h"
#include "gmMatrix.h"
 
#include "gmSingleVector.h"
#include "gmDualVector.h"
 
struct lua_State;
 
class GmValueAccessor;
class GmTrackedValueAccessor;
class GmValueSetData;
class GmMesh;
class GmDiscontinuitySet;
class GmStateDump;
 
class GMC_API_EXPORT GmGroupDumpItem
{
public:
  virtual ~GmGroupDumpItem() {}
 
  virtual bool addStateItemsToGroup(GmStateDump* state, int groupId) = 0;
 
  virtual bool stateAboutToBeSaved(GmStateDump* state) { Q_UNUSED(state); return true; }
 
  virtual bool stateSaved(GmStateDump* state) { Q_UNUSED(state); return true; }
 
  virtual bool stateAboutToBeLoaded(GmStateDump* state) { Q_UNUSED(state); return true; }
 
  virtual bool stateLoaded(GmStateDump* state) { Q_UNUSED(state); return true; }
};
 
//------------------------------------------------------------------------------
// GmStateDumpItemTypes
//------------------------------------------------------------------------------
 
 
enum GmStateDumpItemTypes
{
  GM_AC_DUMP_ITEM          = 0x01000000, 
  GM_FUNCTIONMAP_DUMP_ITEM = 0x02000000, 
  GM_VECTOR_DUMP_ITEM      = 0x03000000, 
  GM_MATRIX_DUMP_ITEM      = 0x04000000, 
  GM_BUFFER_DUMP_ITEM      = 0x05000000, 
  GM_MAP_DUMP_ITEM         = 0x06000000, 
  GM_LUA_DUMP_ITEM         = 0x07000000, 
  GM_FILE_DUMP_ITEM        = 0x08000000, 
  GM_MESH_DUMP_ITEM        = 0x09000000, 
  GM_BC_DUMP_ITEM          = 0x0A000000, 
  GM_SPLITINTVEC_DUMP_ITEM = 0x0B000000, 
  GM_SDVECTOR_DUMP_ITEM    = 0x0C000000, 
  GM_DS_DUMP_ITEM          = 0x0D000000, 
  GM_STREAM_DUMP_ITEM      = 0x0E000000, 
  // ------------------------
  // Do not add entries below this line
  //-------------------------
  GM_DUMP_ITEM_MASK = 0xFF000000, 
};
 
//------------------------------------------------------------------------------
// GmStateDumpBaseDataItem
//------------------------------------------------------------------------------
 
class GMC_API_EXPORT GmStateDumpBaseDataItem : public GmMemoryDumpItem
{
public:
  GmStateDumpBaseDataItem(int id, QString prefix, const GmLogCategory& logger)
    : _id(id), _prefix(prefix), _logger(logger) 
  { 
    assert(id > 0); // The id for the function map items MUST be > 0
    assert(_prefix.size() > 0);
    assert(_prefix.size() < GM_MEMORY_DUMP_ITEM_NAME_SIZE - 10); // Ensure that the prefix size is not too big
  } 
 
  int id() { return _id; }
 
  virtual int itemSize() const { return 0; }
 
  virtual QString itemName() const 
  { 
    QString pref = QString("%1_%2").arg(_prefix).arg(_id);
    QString suf  = nameSuffix();
    if(!suf.isEmpty())
    {
      QString s = QString("%1_%2").arg(pref, suf);
      s.truncate(GM_MEMORY_DUMP_ITEM_NAME_SIZE);
      return s;
    }
    return pref; // The prefix is always smaller than the maximum size
  }
 
protected:
 
  virtual QString nameSuffix() const { return ""; }
 
  int     _id;                  
  QString _prefix;              
  const GmLogCategory& _logger; 
};
 
//------------------------------------------------------------------------------
// GmStateDumpAccessorDataItem
//------------------------------------------------------------------------------
 
class GMC_API_EXPORT GmStateDumpAccessorDataItem : public GmStateDumpBaseDataItem
{
public:
        GmStateDumpAccessorDataItem(int id, const GmMesh* mesh, QString prefix, const GmLogCategory& logger) :
                GmStateDumpBaseDataItem(id, prefix, logger), _mesh(mesh), _hasGeometryNodes(false) { }
 
    virtual bool hasGeometryNodes() const { return _hasGeometryNodes; };
        virtual const GmMesh* mesh() const { return _mesh;}
 
protected:
        const GmMesh* _mesh; // Mesh from which the nodes are from
        bool _hasGeometryNodes; //Should be set from derived class -> Does the accessor has geometry nodes?
};
 
//------------------------------------------------------------------------------
// GmStateDumpFunctionMapDataItem
//------------------------------------------------------------------------------
 
class GMC_API_EXPORT GmStateDumpFunctionMapDataItem : public GmStateDumpAccessorDataItem
{
public:
  GmStateDumpFunctionMapDataItem(int id, const GmMesh* mesh, GmValueAccessor* ac1, GmValueAccessor* ac2, 
                                 const GmLogCategory& logger, QString itemNamePrefix = "");
 
  QString translateFunction (void* ptr, bool evaluator);
  bool    updateFunctionList();
 
  void resetSaved() { _saved = false; }
 
  // See comments on the base class
  virtual int itemType() const { return GM_FUNCTIONMAP_DUMP_ITEM; }
 
  // See comments on the base class
  virtual bool canCompress() const { return false; }
 
  // See comments on the base class
  virtual bool partialOp() const { return false; }
 
  // See comments on the base class
  virtual bool fixedSize() const { return true; }
 
  // See comments on the base class
  virtual qint64 size() const { assert(!_buffer.isEmpty());  return _buffer.size(); }
 
  // See comments on the base class. No need for a header
  virtual bool fillDataHeader(char* header) { Q_UNUSED(header);  return false; }
   
  virtual void getDataBuffer (GmMemoryBufferList& bufferList, qint64 size = 0, qint64 offset = 0);
  virtual bool setDataBuffer (GmMemoryBufferList& bufferList, const char* header, qint64 size, qint64 offset = 0);
  virtual void bufferReleased(int op, bool ok);
 
protected:
  virtual QString nameSuffix() const; 
 
private:
  GmValueAccessor* _ac1;   
  GmValueAccessor* _ac2;   
  bool             _saved; 
  int              _nuser; 
  int              _neval; 
  QVarLengthArray<char> _buffer;    
  QMap<void*, QString>  _userMap;   
  QMap<void*, QString>  _evalMap;   
};
 
//------------------------------------------------------------------------------
// GmStateDumpValueSetDataItem
//------------------------------------------------------------------------------
 
class GMC_API_EXPORT GmStateDumpValueSetDataItem : public GmStateDumpAccessorDataItem
{
public:
  GmStateDumpValueSetDataItem(int id, GmValueAccessor* ac, GmStateDumpFunctionMapDataItem* fmap, int acType, 
                              const GmLogCategory& logger, bool fixed, const GmMesh* mesh, QString itemNamePrefix = "");
 
  virtual ~GmStateDumpValueSetDataItem();
 
  void resetSaved() { _saved = false; }
 
  virtual int itemType() const;
 
  int acType() const { return _acType; }
 
  const GmMesh* mesh() const { return _mesh; }
 
  virtual int itemSize() const;
 
  // See comments on the base class
  virtual bool canCompress() const { return true; }
 
  // See comments on the base class
  virtual bool partialOp() const { return !isDefValueSetData(); }
 
  // See comments on the base class
  virtual bool fixedSize() const { return _fixedHint; }
 
  virtual qint64 size() const;
  virtual bool   fillDataHeader(char* header);
 
  virtual void getDataBuffer (GmMemoryBufferList& bufferList, qint64 size = 0, qint64 offset = 0);
  virtual bool setDataBuffer (GmMemoryBufferList& bufferList, const char* header, qint64 size, qint64 offset = 0);
  virtual void bufferReleased(int op, bool ok);
 
protected:
  virtual QString nameSuffix() const;
 
private:
  bool isDefValueSetData() const;
  void initDefBuffers();
  void fillBufferList(GmMemoryBufferList& bufferList, qint64 size, qint64 offset);
 
  GmValueSetData* detach();
 
  GmTrackedValueAccessor* _ac;     
  int                     _acType; 
  bool  _fixedHint;     
  bool  _saved;         
  bool  _isPacked;      
  char* _defGetBuffer;  
  char* _defSetBuffer;  
  int   _defBufferSize; 
  int   _loadMode;      
 
  GmStateDumpFunctionMapDataItem* _functionMap; 
};
 
//------------------------------------------------------------------------------
// GmStateDumpArmaDataItem
//------------------------------------------------------------------------------
 
template <class T>
class GmStateDumpArmaDataItem : public GmStateDumpBaseDataItem
{
public:
  GmStateDumpArmaDataItem(int id, T* data, const GmLogCategory& logger, bool fixed, QString itemNamePrefix)
    : GmStateDumpBaseDataItem(id, itemNamePrefix, logger)
  {
    assert(id > 0);
    assert(data);
 
    _data = data;
    _fixedHint = fixed;
  }
 
  // See comments on the base class
  virtual int itemSize() const { return sizeof(double); }
 
  // See comments on the base class
  virtual bool canCompress() const { return true; }
 
  // See comments on the base class
  virtual bool partialOp() const { return true; }
 
  // See comments on the base class
  virtual bool fixedSize() const { return _fixedHint; }
 
  // See comments on the base class
  virtual qint64 size() const { return _data->size() * sizeof(double); }
 
  // See comments on the base class. No need for a header
  virtual bool fillDataHeader(char* header) { Q_UNUSED(header);  return false; }
 
  // See comments on the base class
  virtual void getDataBuffer(GmMemoryBufferList& bufferList, qint64 size = 0, qint64 offset = 0)
  {
    Q_UNUSED(size);
    assert(size >= 0 && offset >= 0);
    assert((unsigned)(size + offset) <= _data->size() * sizeof(double));
    if(_data->size())
      bufferList.addBuffer(((char*)_data->memptr()) + offset, size ? size : _data->size() * sizeof(double));
  }
 
  // See comments on the base class
  virtual bool setDataBuffer(GmMemoryBufferList& bufferList, const char* header, qint64 size, qint64 offset = 0)
  {
    Q_UNUSED(header);
    assert(size > 0 && offset >= 0);
 
    if((unsigned)(size + offset) > _data->size() * sizeof(double))
      return false;  // No growing of the vector
    bufferList.addBuffer(((char*)_data->memptr()) + offset, size);
    return true;
  }
 
private:
  T*   _data;       
  bool _fixedHint;  
};
 
//------------------------------------------------------------------------------
// GmStateDumpVectorDataItem
//------------------------------------------------------------------------------
 
class GMC_API_EXPORT GmStateDumpVectorDataItem : public GmStateDumpArmaDataItem<GmVector>
{
public:
  GmStateDumpVectorDataItem(int id, GmVector* vec, const GmLogCategory& logger, bool fixed, 
                            QString itemNamePrefix = "")
    : GmStateDumpArmaDataItem<GmVector>(id, vec, logger, fixed, itemNamePrefix.isEmpty() ? "Vec" : itemNamePrefix) {}
 
  // See comments on the base class
  virtual int itemType() const { return GM_VECTOR_DUMP_ITEM; }
};
 
//------------------------------------------------------------------------------
// GmStateDumpMatrixDataItem
//------------------------------------------------------------------------------
 
class GMC_API_EXPORT GmStateDumpMatrixDataItem : public GmStateDumpArmaDataItem<GmMatrix>
{
public:
  GmStateDumpMatrixDataItem(int id, GmMatrix* mat, const GmLogCategory& logger, bool fixed, 
                            QString itemNamePrefix = "")
    : GmStateDumpArmaDataItem<GmMatrix>(id, mat, logger, fixed, itemNamePrefix.isEmpty() ? "Mat" : itemNamePrefix) {}
 
  // See comments on the base class
  virtual int itemType() const { return GM_MATRIX_DUMP_ITEM; }
};
 
//------------------------------------------------------------------------------
// GmStateDumpBufferDataItem
//------------------------------------------------------------------------------
 
class GMC_API_EXPORT GmStateDumpBufferDataItem : public GmStateDumpBaseDataItem
{
public:
  GmStateDumpBufferDataItem(int id, char** data, int* size, int sizeMultiplier,
                            bool checkSizes, const GmLogCategory& logger, bool fixed, 
                            QString itemNamePrefix = "");
 
  GmStateDumpBufferDataItem(int id, char* data, int size, bool checkSizes, 
                            const GmLogCategory& logger, bool fixed, QString itemNamePrefix = "");
 
  void addBuffer(char** data, int* size, int sizeMultiplier);
  void addBuffer(char*  data, int  size);
 
  void clearBuffers();
 
  // See comments on the base class
  virtual int itemType() const { return GM_BUFFER_DUMP_ITEM; }
 
  // See comments on the base class
  virtual bool canCompress() const { return true; }
 
  // See comments on the base class
  virtual bool partialOp() const { return false; }
 
  // See comments on the base class
  virtual bool fixedSize() const { return _fixedHint; }
 
  // See comments on the base class
  virtual qint64 size() const { return _totalSize; }
 
  virtual bool opStart(int op);
  virtual bool opEnd  (int op);
 
  virtual bool fillDataHeader(char* header);
 
  virtual void getDataBuffer(GmMemoryBufferList& bufferList, qint64 size = 0, qint64 offset = 0);
  virtual bool setDataBuffer(GmMemoryBufferList& bufferList, const char* header, qint64 size, qint64 offset = 0);
 
private:
  class BufferData {
    void* _data;        
    int*  _size;        
    int   _fsize;       
    int   _multiplier;  
  public:
    BufferData() : _data(NULL), _size(NULL), _fsize(0), _multiplier(0) {} // Def constructor needed by QVector
    BufferData(char** d, int* s, int m) : _data(d), _size(s), _fsize(0), _multiplier(m) {}
    BufferData(char*  d, int  s) : _data(d), _size(NULL), _fsize(s), _multiplier(1) {}
 
    int bsize() const { return _size ? (*_size) * _multiplier : _fsize; }
 
    char* bptr() const { return _size ? *((char**)_data) : (char*)_data; }
  };
 
  QVector<BufferData> _bufferDataList; 
  QVector<int>        _sizes;          
  qint64              _totalSize;      
  bool                _fixedHint;      
  bool                _checkSizes;     
};
 
//------------------------------------------------------------------------------
// GmStateDumpSDVectorDataItem
//------------------------------------------------------------------------------
 
template <class Vector> 
class GmStateDumpSDVectorDataItem : public GmStateDumpBaseDataItem
{
public:
  GmStateDumpSDVectorDataItem(int id, Vector* data, bool noresize, const GmLogCategory& logger, 
                              bool fixed, QString itemNamePrefix = "")
    : GmStateDumpBaseDataItem(id, itemNamePrefix.isEmpty() ? "SDVector" : itemNamePrefix, logger)
  {
    S_TRACE(); assert(id > 0); assert(data);
    _data      = data;
    _fixedHint = fixed;
    _noresize  = noresize;
  }
 
  // See comments on the base class
  virtual int itemType() const { return GM_SDVECTOR_DUMP_ITEM; }
 
  // See comments on the base class
  virtual bool canCompress() const { return true; }
 
  // See comments on the base class
  virtual bool partialOp() const { return false; }
 
  // See comments on the base class
  virtual bool fixedSize() const { return _fixedHint; }
 
  // See comments on the base class
  virtual qint64 size() const { return _data->size() * sizeof(Vector::DataType); }
 
  virtual bool fillDataHeader(char* header)
  {
    S_TRACE();
    assert(GM_MEMORY_DUMP_ITEM_DATA_SIZE >= 2 * sizeof(qint64));
 
    qint64* p = (qint64*)header;
    p[0] = _data->numDumpBuffers();
    assert(p[0] > 0 && p[0] <= 2);
 
    qint64 b1 = _data->dumpBufferSize(0);
    qint64 b2 = (p[0] == 2) ? _data->dumpBufferSize(1) : 0;
    assert(b1 <= std::numeric_limits<qint64>::max() - b2); // No overflow expected when adding b1 & b2
 
    p[1] = b1 + b2;
    return true;
  }
 
  // See comments on the base class
  virtual void getDataBuffer(GmMemoryBufferList& bufferList, qint64 size = 0, qint64 offset = 0)
  {
    S_TRACE(); Q_UNUSED(size); Q_UNUSED(offset);
    assert(size == 0 && offset == 0); // No support for partial save
 
    for(int i = 0, n = _data->numDumpBuffers(); i < n; i++)
    {
      qint64 s = _data->dumpBufferSize(i);
      if(s)
        bufferList.addBuffer(_data->dumpBuffer(i), s);
    }
  }
 
  // See comments on the base class
  virtual bool setDataBuffer(GmMemoryBufferList& bufferList, const char* header, qint64 size, qint64 offset = 0)
  {
    S_TRACE(); Q_UNUSED(header); Q_UNUSED(offset);
    assert(size > 0 && offset == 0);
 
    qint64* p = (qint64*)header;
    if(size != p[1])
      return false; // Unexpected buffer size!
 
    int items = (int)(size / sizeof(Vector::DataType));
    assert(items * sizeof(Vector::DataType) == size); // size was a multiple of the item size!
 
    if(_data->size() != items)
    {
      if(_noresize)
        return false; // error. Buffers don't have the expected size and noresize was specified!
      _data->clear();
      _data->addValues(items);
    }
 
    for(int i = 0, n = _data->numDumpBuffers(); i < n; i++)
      bufferList.addBuffer(_data->dumpBuffer(i), _data->dumpBufferSize(i));
    return true;
  }
 
private:
  Vector* _data;       
  bool    _fixedHint;  
  bool    _noresize;   
};
 
typedef GmStateDumpSDVectorDataItem<GmSingleVector<int>> GmStateDumpSingleVectorIntDataItem;
 
typedef GmStateDumpSDVectorDataItem<GmDualVector<int>> GmStateDumpDualVectorIntDataItem;
 
//------------------------------------------------------------------------------
// GmStateDumpSplitIntVecDataItem
//------------------------------------------------------------------------------
 
class GMC_API_EXPORT GmStateDumpSplitIntVecDataItem : public GmStateDumpBaseDataItem
{
public:
  GmStateDumpSplitIntVecDataItem(int id, QList<int*>* dataList, QList<int>* sizeList, bool compact,
                                 const GmLogCategory& logger, bool fixed, QString itemNamePrefix = "");
 
  // See comments on the base class
  virtual int itemType() const { return GM_SPLITINTVEC_DUMP_ITEM; }
 
  // See comments on the base class
  virtual bool canCompress() const { return true; }
 
  // See comments on the base class
  virtual bool partialOp() const { return false; }
 
  // See comments on the base class
  virtual bool fixedSize() const { return _fixedHint; }
 
  // See comments on the base class
  virtual qint64 size() const { return _totalSize; }
 
  virtual bool opStart(int op);
 
  virtual bool fillDataHeader(char* header);
 
  virtual void getDataBuffer(GmMemoryBufferList& bufferList, qint64 size = 0, qint64 offset = 0);
  virtual bool setDataBuffer(GmMemoryBufferList& bufferList, const char* header, qint64 size, qint64 offset = 0);
 
private:
  bool         _compact;    
  QList<int*>* _dataList;   
  QList<int>*  _sizeList;   
  qint64       _totalSize;  
  bool         _fixedHint;  
};
 
//------------------------------------------------------------------------------
// GmStateDumpMapDataItem
//------------------------------------------------------------------------------
 
template <class K, class V>
class GMC_API_EXPORT GmStateDumpMapDataItem : public GmStateDumpBaseDataItem
{
public:
  GmStateDumpMapDataItem(int id, QMap<K, V>* data, bool fixedHint, const GmLogCategory& logger,
                         QString itemNamePrefix = "");
 
  // See comments on the base class
  virtual int itemType() const { return GM_MAP_DUMP_ITEM; }
 
  // See comments on the base class
  virtual bool canCompress() const { return true; }
 
  // See comments on the base class
  virtual bool partialOp() const { return false; }
 
  // See comments on the base class
  virtual bool fixedSize() const { return _fixedHint; }
 
  virtual bool opStart(int op);
  virtual bool opEnd(int op);
 
  // See comments on the base class
  virtual qint64 size() const { assert(!_data.isEmpty()); return _data.size(); }
 
  // See comments on the base class. No need for a header
  virtual bool fillDataHeader(char* header) { Q_UNUSED(header);  return false; }
 
  virtual void getDataBuffer(GmMemoryBufferList& bufferList, qint64 size = 0, qint64 offset = 0);
  virtual bool setDataBuffer(GmMemoryBufferList& bufferList, const char* header, qint64 size, qint64 offset = 0);
  virtual void bufferReleased(int op, bool ok);
 
protected:
  virtual bool fillMapData(QMap<K, V>* map) { Q_UNUSED(map); return true; }
 
  virtual bool mapDataLoaded(QMap<K, V>* map) { Q_UNUSED(map); return true; }
 
private:
  QMap<K, V>* _varMap;     
  bool        _fixedHint;  
  QByteArray  _data;       
};
 
//------------------------------------------------------------------------------
// GmStateDumpVariantMapDataItem
//------------------------------------------------------------------------------
 
class GMC_API_EXPORT GmStateDumpVariantMapDataItem : public GmStateDumpMapDataItem<QString, QVariant>
{
public:
  GmStateDumpVariantMapDataItem(int id, QVariantMap* data, bool fixedHint, const GmLogCategory& logger,
                                QString itemNamePrefix = "")
    : GmStateDumpMapDataItem<QString, QVariant>(id, data, fixedHint, logger, 
                                                itemNamePrefix.isEmpty() ? "VarMap" : itemNamePrefix) {}
};
 
//------------------------------------------------------------------------------
// GmStateDumpFileItem
//------------------------------------------------------------------------------
 
class GMC_API_EXPORT GmStateDumpFileItem : public GmStateDumpVariantMapDataItem
{
public:
  GmStateDumpFileItem(int id, FILE* fhandle, QString fileName, QString tempName, 
                      const GmLogCategory& logger, QString itemNamePrefix = "");
 
  // See comments on the base class
  virtual int itemType() const { return GM_FILE_DUMP_ITEM; }
 
protected:
  virtual bool fillMapData  (QVariantMap* map);
  virtual bool mapDataLoaded(QVariantMap* map);
 
private:
  FILE*       _fileh;       
  QString     _baseName;    
  QString     _fileName;    
  QVariantMap _dataMap;     
};
 
//------------------------------------------------------------------------------
// GmStateDumpLuaDataItem
//------------------------------------------------------------------------------
 
class GMC_API_EXPORT GmStateDumpLuaDataItem : public GmStateDumpBaseDataItem
{
public:
  GmStateDumpLuaDataItem(int id, lua_State* L, const QStringList& globals,
                         const QStringList& locals, QString localTabName, 
                         const GmLogCategory& logger, QString itemNamePrefix = "");
 
  // See comments on the base class
  virtual int itemType() const { return GM_LUA_DUMP_ITEM; }
 
  // See comments on the base class
  virtual bool canCompress() const { return true; }
 
  // See comments on the base class
  virtual bool partialOp() const { return false; }
 
  // See comments on the base class
  virtual bool fixedSize() const { return false; }
 
  // See comments on the base class
  virtual bool opStart(int op) { return op == 0 ? loadDataFromLuaState() : true; }
 
  // See comments on the base class
  virtual qint64 size() const { assert(!_data.isEmpty()); return _data.size(); }
 
  // See comments on the base class. No need for a header
  virtual bool fillDataHeader(char* header) { Q_UNUSED(header);  return false; }
 
  virtual void getDataBuffer (GmMemoryBufferList& bufferList, qint64 size = 0, qint64 offset = 0);
  virtual bool setDataBuffer (GmMemoryBufferList& bufferList, const char* header, qint64 size, qint64 offset = 0);
  virtual void bufferReleased(int op, bool ok);
 
private:
  bool loadDataFromLuaState();
  void saveDataToLuaState();
 
  lua_State*  _L;             
  QStringList _globals;       
  QStringList _locals;        
  QString     _localTabName;  
  QByteArray  _data;          
};
 
 
 
template <class T>
class GMC_API_EXPORT GmStateDumpStreamableItem : public GmStateDumpBaseDataItem
{
public:
    GmStateDumpStreamableItem(int id, T* item, const GmLogCategory& logger,
        QString prefix = "") : GmStateDumpBaseDataItem(id, prefix, logger), _item(item) {}
 
    virtual bool canCompress() const { return true; }
    virtual int itemType() const { return GM_STREAM_DUMP_ITEM; }
    virtual bool partialOp() const { return false; }
    virtual bool fillDataHeader(char* header) { Q_UNUSED(header);  return false; }
 
        virtual bool fixedSize() const { return true; }
 
    virtual bool opStart(int op);
    virtual bool opEnd(int op);
    virtual qint64 size() const { assert(!_data.isEmpty()); return _data.size(); }
 
    virtual void getDataBuffer(GmMemoryBufferList& bufferList, qint64 size = 0, qint64 offset = 0);
    virtual bool setDataBuffer(GmMemoryBufferList& bufferList, const char* header, qint64 size, qint64 offset = 0);
    virtual void bufferReleased(int op, bool ok);
 
protected:
    T* _item;                 
    QByteArray  _data;        
};
 
 
class GMC_API_EXPORT GmStateDumpDiscontinuityStreamItem : public GmStateDumpStreamableItem<GmDiscontinuitySet> {
 
public:
    GmStateDumpDiscontinuityStreamItem(int id, GmDiscontinuitySet* item, const GmLogCategory& logger) : GmStateDumpStreamableItem(id, item, logger, "DSet") {}  
};
 
 
#endif