simStatement.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2018 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#pragma once

class DtSimStatement;

#include <vlutil/vlString.h>
#include <vlutil/vlList.h>
#include <readerWriter/readerWriter.h>
#include "vrfutil/rwIntrusiveList.h"
#include "vrfplan/statementFactory.h"
#include "vrfutil/rwUUID.h"
#include <readerWriter/rwString.h>
#include "vrfutil/stringIntMapper.h"
#include <vlutil/vlNetTypes.h>
#include "tdbutil/unitFormatter.h"
#include "tdbutil/tdbUnits.h"

#include <boost/unordered_map.hpp>

typedef int DtStmtIdType;

class DtPlan;
class DtSimBlock;
class DtStmtIndex;
class DtRecursiveSimStatementIterator;

#include "vrfplan/vrfplanDefines.h"
class DT_DLL_vrfplan DtSimStatement : public DtRwListedObj
{
public:
   friend class DtStmtIndex;

   DtSimStatement();

   DtSimStatement(const DtString& name,
      DtReaderWriterRegistry* parentRegistry = NULL);

   DtSimStatement(const DtSimStatement& orig,
      DtReaderWriterRegistry* parentRegistry = NULL);

   virtual ~DtSimStatement();

   virtual bool init();

   DtSimStatement& operator=(const DtSimStatement& orig);

   virtual DtSimStatement* clone(
      DtReaderWriterRegistry* parentRegistry = NULL) const = 0;

   virtual int type() const = 0;

   virtual bool validate();

   virtual void execute(DtPlan& planContext) = 0;

   virtual void step(DtPlan& planContext, bool forceStep = false);

   DtSimStatement* nextStmt() const;
   DtSimStatement* prevStmt() const;

   virtual DtStmtIdType statementId() const;
   virtual void setStatementId(DtStmtIdType arg);

   virtual DtSimBlock* parentBlock() const;
   virtual void setParentBlock(DtSimBlock* arg);

   virtual int subBlockCount() const;

   virtual DtSimBlock* subBlock(int index);

#ifndef WIN32
   static const int DtSR_STMT = -1;
#else
   enum
   {
      DtSR_STMT = -1
   };
#endif

   virtual DtRecursiveSimStatementIterator* spawnRecursiveIterator() const;

   virtual DtSimStatement* lookupStatement(DtStmtIdType statementId);

   virtual void setStatementDescription(const DtString&);
   virtual const DtString& statementDescription() const;

   virtual DtString stringRep(int subBlockIndex = DtSR_STMT) const = 0;

   virtual char* netRep();

   virtual int netRepSize() const;

   virtual bool setFromNet(const char* contentBuffer, unsigned contentSize);

   virtual bool setToNet();

   static DtStmtIdType generateNewStmtId();


   static DtSimStatement * createStatement(DtlObjPtr mtlStream,
      DtReaderWriterRegistry* parentRegistry = NULL);
   static DtSimStatement * createStatement(int statementType,
      DtReaderWriterRegistry* parentRegistry = NULL);


   static void addStatementCreatorFcn(const DtString & type, int intType,
      DtStatementCreatorFcn fcn);

   static void setFactory(DtStatementFactory * factory);
   static DtStatementFactory * factory();


   static bool getStatementNameFromStatementType(int statementType, DtString& statementName);
   static bool getStatementTypeFromStatementName(const DtString& statementName, 
      int& statementType);

   static bool addStatementTypeMapping(const DtString& statementName, int taskType);
   static bool removeStatementTypeMapping(const DtString& statementName, 
      int statementType);

   virtual bool isSameStatement(DtSimStatement*);

   virtual void upgradeTriggerUUID(const boost::unordered_map<DtUUID, DtUUID>&);

   virtual void reset();

protected:
   virtual char* createNetworkBuffer();

   virtual bool compare(DtSimStatement*);

protected:

   DtStmtIdType myStatementId;

   DtSimBlock* myParentBlock;

   static DtStatementFactory * myFactory;

   char*     myNetRep;

   static DtStringIntMapper theStatementNameMapper;

   DtRwString myStatementDescription;
};

inline DtSimStatement* DtSimStatement::nextStmt() const
{
   return (DtSimStatement*) next();
}
inline DtSimStatement* DtSimStatement::prevStmt() const
{
   return (DtSimStatement*) prev();
}

namespace DtBufferSerialize
{
   DT_DLL_vrfplan char *encode(const DtSimStatement* val, char *buffer);
   DT_DLL_vrfplan const char *decode(DtSimStatement*& val, const char *buffer);
   DT_DLL_vrfplan int getSize(const DtSimStatement*);
}