plan.h

Go to the documentation of this file.

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


#ifndef DtPlan_H_
#define DtPlan_H_

class DtPlan;

#include <vlutil/vlString.h>
#include <vlutil/vlList.h>
#include "vrfutil/rwString.h"
#include "vrfutil/rdrWritr.h"
#include "vrfplan/stmtIndex.h"
#include <vl/hostStructs.h>
#include "vrfutil/rwBoolean.h"
#include "vrfutil/rwIntegerList.h"
#include "vrfplan/rwTriggerDataList.h"
#include "vrfplan/rwPlanExecutionStack.h"
#include "vrfutil/callbackList.h"
#include "vrfplan/vrfplanDefines.h"

class DtStatement;
class DtSimTask;
class DtSetDataRequest;
class DtSimInterfaceContent;
class DtSimTrigger;
class DtSimBlock;
class DtSimCommand;
class DtPlanBlock;
class DtWhenBlock;
class DtSimMessage;
class DtRecursiveSimBlockIterator;
class DtVrfMessageInterface;
class DtPlanExecutor;
class DtSimCondExpr;
class DtIfMultiplePlanResponse;

class DT_DLL_vrfplan DtPlanStatus
{
public:
   DtPlanStatus();
   bool operator==(const DtPlanStatus& orig) const;
   bool operator!=(const DtPlanStatus& orig) const;


   int currentStatementId;
   bool isComplete;
   bool isExecuting;
   bool isAbandoned;
};

typedef void (*DtCurrentStatementChangedCallbackFcn)
   (const DtPlan& plan, void* usr);

typedef void (*DtPlanCallbackFcn)
   (const DtString& name, const DtList& statements, bool append, 
   void* usr);

typedef void (*DtPlanStatementCallbackFcn)
   (const DtString& name, DtPlanStatus planStatus, void* usr);

typedef void (*DtPlanCompleteCallbackFcn)
   (const DtString& name, void* usr);

typedef void (*DtMultiplePlanRequestCallbackFcn)
   (DtIfMultiplePlanResponse*, void* usr);

class DT_DLL_vrfplan DtPlan : public DtReaderWriter
{
public:

   DtPlan();

   DtPlan(const DtString& planName,
      DtPlanExecutor* planExecutor,      
      const DtString& name = "Plan",
      DtReaderWriterRegistry* parentRegistry = NULL);


   DtPlan(const DtString& name, const DtString& planName,
      const DtPlan& orig, DtReaderWriterRegistry* parentRegistry = NULL);

   virtual ~DtPlan();

   virtual void init();

   virtual DtPlan* clone(const DtString& name,
      const DtString& planName,
      DtReaderWriterRegistry* parentRegistry = NULL) const;

   DtPlan& operator=(const DtPlan& orig);

   virtual bool operator==(const DtPlan& orig) const;

   virtual DtString planName() const;
   virtual void setPlanName(const DtString& name);

   virtual const DtString& objectName() const;
   virtual void setObjectName(const DtString& objectName);
   virtual bool objectNameSpecified() const;

   //virtual DtSimManager* simManager() const;

   virtual void setPlanExecutor(DtPlanExecutor* planExecutor);
   virtual DtPlanExecutor* planExecutor() const;

   virtual void enableExecutionState();
   virtual void disableExecutionState();
   virtual bool executionState() const;

   virtual void awaitingTask();

   virtual bool isAwatingTask() const;

   virtual void pushExecutionStack();

   virtual void popExecutionStack(bool forceStep = false);

   virtual void executeTrigger(DtWhenBlock* whenBlock);

   virtual void executeBlock(DtSimBlock* block);

   virtual bool taskRequestPending() const;

   virtual void setTaskRequestPending(bool newValue = true);

   virtual bool executeTask(const DtSimTask& taskToSend) const;

   virtual bool executeSetDataRequest(
      const DtSetDataRequest& setToSend) const;

   virtual bool executeSimCommand(const DtSimCommand& command) const;

   virtual bool evaluateConditional(const DtSimCondExpr* condExpr) const;

   virtual DtStmtIndex firstStmt() const;

   virtual DtPlanBlock* mainBlock() const;

   virtual bool isEmpty() const;

   virtual DtList* triggerList();
   virtual const DtList* triggerList() const;

   virtual void addTrigger(DtSimTrigger* trigger);
   virtual void removeTrigger(DtSimTrigger* trigger);

   virtual DtList* executionStack();
   virtual const DtList* executionStack() const;

   virtual bool validatePlan();

   virtual const DtStmtIndex& currentStmt() const;
   virtual void setCurrentStmt(const DtStmtIndex& nextStatement);

   virtual void setCurrentStatementExecutionId(int id);

   virtual bool isComplete() const;
   virtual void setIsComplete(bool completeFlag = true);

   virtual bool isAbandoned() const;
   virtual void setIsAbandoned(bool v);
   
   virtual bool isExecuting() const;

   virtual DtPlanStatus currentStatus() const;

   virtual void reset();

   virtual void abandonPlan(bool sendWaitTask);

   virtual void restartPlan(bool sendWaitTask = true);

   virtual bool translateIndex(DtStmtIndex& stmtIndex) const;

   virtual void translateIndices(DtList& stmtIndexList) const;

   virtual void tick();

   virtual void mergeEditedPlanWith(const DtPlan& oldPlan);

   virtual DtRecursiveSimBlockIterator* spawnRecursiveIterator() const;

   virtual void putSelf(FILE *fp, int indentLevel = 0, 
      bool writeUnspecified = false, const DtFilename& path = DtReaderWriter::appPath());
   
   virtual void getSelf(DtlObjPtr args, const DtFilename& searchPath, 
      const DtVariableBindingsList& variableBindings);  

   virtual void addStatementChangedCallback(
      DtCurrentStatementChangedCallbackFcn fcn, void* usrData);

   virtual void removeStatementChangedCallback(
      DtCurrentStatementChangedCallbackFcn fcn, void* usrData);
      
protected:
   
   virtual void processAwaitingTask();

   virtual void createMainBlock();

   virtual void copyMainBlock(const DtPlan& otherPlan);

   virtual void copyAndTranslateExecutionStack(const DtPlan& otherPlan);

   virtual void copyAndTranslateTriggers(const DtPlan& otherPlan);

   virtual void curStmtChanged();

   virtual void continuePlan();

   virtual void stepStatement();

   virtual void executeStatement();

   virtual void clearTriggerList();

   virtual void clearExecutionStack();

   virtual void emtpyExecutionStack();



   virtual void mapExecutionStackToRwExecutionStack(DtRwPlanExecutionStack& rwExecutionStack);
   virtual void mapPendingTriggersToPendingTriggerDataList();



   virtual void mapOldExecutionCursorStackToExecutionStack(const DtRwIntegerList& executionCursorStack);
   virtual void mapRwExecutionStackToExecutionStack(const DtRwPlanExecutionStack& rwExecutionStack);
   virtual void mapPendingTriggerDataToPendingTriggers();

   virtual int statementIdToCursor(DtStmtIdType statementId);
   virtual DtStmtIdType cursorToStatementId(int cursor);

   virtual DtSimStatement* lookupStatementByCursor(int cursor);

protected:

   DtRwBoolean myTaskRequestPending;

   DtPlanBlock* myMainBlock;

   DtList myExecutionStack;

   DtRwBoolean myIsComplete;

   DtRwBoolean myAbandoned;

   DtList myPendingTriggers;

   DtCallbackList<const DtPlan&> myStatementChangedCbs;
   //DtList myStatementChangedCbs;


   DtRwTriggerDataList myPendingTriggerDataList;

   bool myExecutionIsEnabled;

   bool myAwaitingTaskFlag;

   DtRwString myPlanName;

   bool  myContinuePlan;

   DtPlanExecutor* myPlanExecutor;

   DtPlanStatus myLastSentStatus;
};

namespace DtBufferSerialize
{
   DT_DLL_vrfplan int getSize(const DtPlan&  contentPtr);

   DT_DLL_vrfplan char *encode(const DtPlan& adminContentPtr, char *buffer);

   DT_DLL_vrfplan const char *decode(DtPlan& adminContentPtr, const char *buffer);
}


#endif