gmStateDump.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_H_
#define _GEMA_STATE_DUMP_H_
 
#include "gmMemoryDump.h"
 
#include "gmVector.h"
#include "gmMatrix.h"
 
class  LuaTable;
struct lua_State;
 
class GmSimulationData;
class GmValueAccessor;
class GmCellAccessor;
class GmGaussAccessor;
class GmBoundaryConditionAccessor;
class GmAccessorProxy;
class GmMesh;
class GmBoundaryCondition;
class GmContactBoundaryCondition;
class GmDiscontinuityAccessor;
class GmDiscontinuitySet;
class GmStateDumpBaseDataItem;
class GmGroupDumpItem;
 
 
class GMC_API_EXPORT GmStateDump
{
public:
  GmStateDump(const GmSimulationData* simulation);
  virtual ~GmStateDump();
 
  void setMode(GmMemoryDumpMode mode) { assert(!_md); _mode = mode; }
 
  void setSaveAndRestoreSupport(bool mode) { assert(!_md); _saveAndRestoreSupport = mode; }
 
  void setDumpFile(QString file);
 
  void setCompression(int level, int minSize) { assert(!_md); _compression = level; _compressionMinSize = minSize; }
 
  void setGrowFactors(double a, int b) { assert(!_md); _growAFactor = a; _growBFactor = b; }
 
  void setPrintStructure(bool mode) { assert(!_md); _printStructure = mode; }
 
  bool loadUserDefinitions(LuaTable& table, QString& err);
 
  int addStateItem(GmValueAccessor*             ac, const GmMesh* mesh, bool fixedHint, bool ownership = false, int groupId = -1, QString prefix = "");
  int addStateItem(GmCellAccessor*              ac, const GmMesh* mesh, bool fixedHint, bool ownership = false, int groupId = -1, QString prefix = "");
  int addStateItem(GmGaussAccessor*             ac, const GmMesh* mesh, bool fixedHint, bool ownership = false, int groupId = -1, QString prefix = "");
  int addStateItem(GmBoundaryConditionAccessor* ac, const GmBoundaryCondition* bc, bool fixedHint, bool ownership = false, int groupId = -1, QString prefix = "");
  int GmStateDump::addStateItem(GmDiscontinuityAccessor* ac, const GmDiscontinuitySet* ds,
                                bool fixedHint, bool ownership, int groupId = -1, QString prefix = "");
  int addStateItem(GmVector*    data,   bool fixedHint, int groupId = -1, QString prefix = "");
  int addStateItem(GmMatrix*    data,   bool fixedHint, int groupId = -1, QString prefix = "");
  int addStateItem(QVariantMap* data,   bool fixedHint, int groupId = -1, QString prefix = "");
  int addStateItem(char**       data,   int* size, int sizeMultiplier, bool fixedHint, int groupId = -1, QString prefix = "");
  int addStateItem(lua_State* L, const QStringList& globals, const QStringList& locals, QString localTabName, int groupId = -1, QString prefix = "");
  int addStateItem(FILE* fhandle, QString fileName, QString tempName, int groupId = -1, QString prefix = "");
  int addStateItem(GmStateDumpBaseDataItem* item, int groupId = -1);
 
  int addGroupItem(GmGroupDumpItem*            obj, int groupId = -1);
  int addGroupItem(GmBoundaryCondition*         bc, int groupId = -1);
  int addGroupItem(GmContactBoundaryCondition* cbc, int groupId = -1);
  int addGroupItem(GmDiscontinuitySet*          ds, int groupId = -1);
 
  GmStateDumpBaseDataItem* stateItem(int itemId) const { assert(_md); return (GmStateDumpBaseDataItem*)_md->item(itemId); }
 
  int stateItemGroup(int itemId) const { assert(_md); return _md->itemGroup(itemId); }
 
  int numStateItems() const { assert(_md); return _md->numItems(); }
 
  int findStateItem(QString name, int typeMask = 0, int typeValue = 0, int groupId = -1, int start = 0)
  {
    assert(_md);
    return _md->findItem(name, typeMask, typeValue, groupId, start);
  }
 
  void setGroupActive(int groupId, bool active);
 
  bool init();
  
  bool save();
  bool load();
 
  bool saveItem(int itemId, qint64 size = 0, qint64 offset = 0);
  bool loadItem(int itemId, qint64 size = 0, qint64 offset = 0);
 
  bool saveActiveGroups();
  bool loadActiveGroups();
 
  void flush() { assert(_md && _init);  _md->flush(); }
 
  void clear() { assert(_md && _init); _md->clear(); }
 
  const GmLogCategory& logger() const { return _logger; }
 
  int nextIdInGroup(int groupId);
 
private:
  Q_DISABLE_COPY(GmStateDump)
 
  int addAcStateItem(GmValueAccessor* ac, const GmMesh* mesh, QString mapId, bool fixedHint, 
                     bool ownership, int groupId, QString prefix, bool* added);
 
  void newmd();
  bool notifyGroupObjects(bool load, bool done, bool activeOnly);
 
  GmMemoryDumpMode _mode;                   
  bool             _saveAndRestoreSupport;  
  QString          _dumpFile;               
  int              _compression;            
  int              _compressionMinSize;     
  double           _growAFactor;            
  int              _growBFactor;            
  bool             _printStructure;         
 
  const GmSimulationData*   _simulation;          
  GmLogCategory             _logger;              
  GmMemoryDump*             _md;                  
  bool                      _init;                
  QMap<int, int>            _currIdInGroup;       
  QVector<int>              _funcItems;           
  QMap<QString, int>        _acMap;               
  QVector<GmValueAccessor*> _ownedValueAccessors; 
  QVector<GmAccessorProxy*> _ownedProxyAccessors; 
  QVector<GmGroupDumpItem*> _ownedGroupItems;     
 
  QMap<int, QPair<GmGroupDumpItem*, bool> > _groupItems;
};
 
#endif