simStmt.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 1999 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: simStmt.h,v $ $Revision: 1.29 $ $State: Exp $
*******************************************************************************/


#ifndef DtSimStatement_H_
#define DtSimStatement_H_

class DtSimStatement;

#include <vlutil/vlString.h>
#include <vlutil/vlList.h>
#include "vrfutil/rdrWritr.h"
#include "vrfutil/rwIntList.h"
#include "vrfplan/stmtFactory.h"
#include "vrfutil/strIntMapper.h"
#include <vlutil/vlNetTypes.h>
#include "tdbutil/translation.h"
#include "tdbutil/tdbUnits.h"

typedef int DtStmtIdType;

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

struct DtNetSimStatement
{
   DtNetU16       myStatementSize;          
   DtNetU16       myStatementId;            
   DtNetU8        myStatementType;          
   DtNetU8        myPadding1;               
   DtNetU16       myPadding2;               
};

#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);

   virtual bool translateIndex(DtStmtIndex& index);

   virtual void translateIndices(const DtList& indices);

   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 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*);

protected:
   virtual char* createNetworkBuffer();

   virtual bool compare(DtSimStatement*);

protected:

   DtStmtIdType myStatementId;

   DtSimBlock* myParentBlock;

   static DtStatementFactory * myFactory;

   char*     myNetRep;

   static DtStringIntMapper theStatementNameMapper;
};

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

#endif