plan.h

Go to the documentation of this file.

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


#pragma once

class DtPlan;

#include <vlutil/vlString.h>
#include <vlutil/vlList.h>
#include <readerWriter/rwString.h>
#include <readerWriter/readerWriter.h>
#include "vrfplan/stmtIndex.h"
#include <vl/hostStructs.h>
#include <readerWriter/rwBoolean.h>
#include "vrfutil/rwIntegerList.h"
#include "vrfplan/rwTriggersList.h"
#include <readerWriter/rwVariableBindings.h>
#include "vrfplan/rwTriggerDataList.h"
#include "vrfplan/rwPlanExecutionStackEntry.h"
#include <readerWriter/noArgumentCallbackList.h>
#include "vrfplan/vrfplanDefines.h"
#include "vrfutil/rwUUID.h"
#include "vrfplan/simCommandStmt.h"

#include <set>

class DtSimTask;
class DtSetDataRequest;
class DtSimTrigger;
class DtSimCommand;
class DtSimMessage;
class DtPlanBlock;
class DtTriggerBlock;
class DtRecursiveSimBlockIterator;
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;

   std::vector<int> executingTriggerStatementIds;
   std::vector<DtUUID> executingTriggerNames;
   std::vector<DtUUID> registeredTriggerNames;
   int currentStatementId;
   bool isComplete;
   bool isExecuting;
   bool isAbandoned;
};

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

typedef void(*DtStmtTickCallbackFcn)
   (DtPlan& plan, void* usr);

typedef void(*DtSkipTaskCallbackFcn)
   (void* usr);

typedef void (*DtPlanCallbackFcn)
   (const DtUUID& name, const std::vector<DtSimStatement*>& statements, bool append, 
   void* usr);

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

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

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

class DT_DLL_vrfplan DtPlan : public DtReaderWriter
{
public:
   enum QuickLaunchFlags
   {
      None = 0,
      IsQuickLaunch = 0x00000001,
      ShowOnQuickLaunchToolbar = 0x00000002,
      Launched = 0x00000004
   };

   DtPlan();

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


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

   virtual ~DtPlan();

   virtual void init();

   virtual void addVariables();

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

   DtPlan& operator=(const DtPlan& orig);

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

   virtual const DtUUID& planName() const;
   virtual void setPlanName(const DtUUID& name);
   virtual bool planNameSpecified() const;

   virtual void setIsQuickLaunch(bool);
   virtual bool isQuickLaunch() const;

   virtual void setShowOnQuickLaunchToolbar(bool);
   virtual bool showOnQuickLaunchToolbar() const;

   virtual void setIsLaunched(bool);
   virtual bool isLaunched() const;

   virtual void setQuickLaunchIcon(const DtString&);
   virtual const DtString& quickLaunchIcon() const;

   virtual void setOrdinal(int);
   virtual int ordinal() 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 addTrigger(const DtTriggerStmt&);

   virtual DtTriggerStmt* triggerStatement(const DtUUID&) const;

   virtual void removeTrigger(const DtUUID&);

   virtual void renameTrigger(const DtUUID&, const DtString& newName);

   virtual void updateTrigger(const DtTriggerStmt*);

   virtual void setTriggers(const DtRwTriggersList&);

   const DtRwTriggersList& triggers() const { return myTriggers; };

   virtual void pushExecutionStack();

   virtual void suspendExecutionStack();

   virtual void popExecutionStack(bool forceStep = false);

   virtual void executeTrigger(DtTriggerBlock* whenBlock);

   virtual void executeBlock(DtSimBlock* block);

   virtual bool taskRequestPending() const;

   virtual void setTaskRequestPending(bool newValue = true);

   const DtRwVariableBindings& variables() const { return myPlanVariables; };

   virtual DtReaderWriter* variable(const DtString&);

   virtual void clearVariables();

   virtual void addVariable(DtRwPlanVariable*);

   virtual void setVariables(const DtRwVariableBindings&);

   virtual bool executeTask(const DtSimTask& taskToSend) const;

   virtual bool executeSetDataRequest(
      const DtSetDataRequest& setToSend) const;

   virtual bool executeSimCommand(const DtSimCommand& command, DtSimCommandContextPtr& context) const;

   virtual bool isSimCommandComplete(const DtSimCommand& command, const DtSimCommandContextPtr& context) const;

   virtual bool evaluateConditional(const DtSimCondExpr* condExpr) const;

   virtual DtStmtIndex firstStmt() const;

   virtual DtPlanBlock* mainBlock() const;

   virtual void empty();

   virtual bool isEmpty() const;

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

   virtual void addTriggerToExecute(DtSimTrigger* trigger);
   virtual void removeTriggerFromPendingExecution(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 void setLastStatementExecuted(bool);
   virtual bool lastStatementExecuted() const;

   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(std::string& fp, int indentLevel = 0, 
      bool writeUnspecified = false, const DtFilename& path = DtReaderWriter::appPath());
   
   virtual void getSelf(DtlObjPtr args, 
      const DtReaderWriter::SearchPaths& searchPaths = DtReaderWriter::SearchPaths(), 
      const DtVariableBindingsList& variableBindings = DtReaderWriter::nullVariableReference());  

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

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

   virtual void addTickCallback(
      DtStmtTickCallbackFcn fcn, void* usrData);

   virtual void removeTickCallback(
      DtStmtTickCallbackFcn fcn, void* usrData);

   virtual void reissueStatementIds(DtSimStatement* stmt);

   virtual void pushExecutingTrigger(int);
   virtual void popExecutingTrigger();
   virtual int executingTriggerStatementId() const;

   virtual std::vector<int> executingTriggerStatementIds() const;

   virtual DtUUID executingTriggerName() const;

   virtual std::vector<DtUUID> executingTriggerNames() const;

   virtual std::vector<DtUUID> registeredTriggerNames() const;

   virtual bool triggerIsRunning(const DtUUID&) const;

   virtual bool triggerIsRegistered(const DtUUID&) const;

   virtual void removeScheduledTriggers(const DtUUID&);

   virtual void mapRegisteredTriggersToTriggerStatements();

   virtual DtSimStatement* lookupStatementByCursor(int cursor);
   virtual DtSimStatement* lookupStatementByStatementId(int) const;

   virtual void setContinuePlan(bool);

   virtual std::vector<DtReaderWriter*> substituteVariablesIn(DtReaderWriter*) const;

   virtual std::vector<DtReaderWriter*> substitutedValues(const DtReaderWriter*) const;

   virtual bool subsituteUUIDIfAvailable(const DtReaderWriter*, DtUUID& uuid) const;

   virtual void removeTopExecutionStack();

   virtual void addSkipTaskCallback(DtSkipTaskCallbackFcn fcn, void* usrData);

   virtual void removeSkipTaskCallback(DtSkipTaskCallbackFcn fcn, void* usrData);

   virtual void invokeSkipTaskCallbacks();

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(bool forceStep = false);

   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* lookupStatementByStatementId(DtSimBlock*, int, std::set<DtUUID>& triggersVisited) const;

   virtual void createTriggersFromWhenBlocks();
   virtual void createTriggersFromWhenBlocks(DtSimBlock*);
   virtual void createTriggersFromWhenBlocks(DtSimBlock*, DtSimStatement*);

   virtual void removeTriggerRegistrationFrom(DtSimBlock*, const DtUUID&);
   virtual void removeTriggerRegistrationFrom(DtSimBlock*, DtSimStatement*, const DtUUID&);

   virtual void mapExecutionStackToExecutingTriggers();

protected:

   DtRwBoolean myTaskRequestPending;

   DtPlanBlock* myMainBlock;

   DtList myExecutionStack;

   DtRwBoolean myIsComplete;

   DtRwBoolean myLastStatementExecuted;

   DtRwBoolean myAbandoned;

   DtList myPendingTriggers;

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

   DtCallbackList<DtPlan&> myStatementTickCbs;
   //DtList myStatementTickCbs;

   DtNoArgumentCallbackList myStatementSkipTaskCbs;
   //DtList myStatementSkipTaskCbs;


   DtRwTriggerDataList myPendingTriggerDataList;

   DtRwTriggersList myTriggers;

   bool myExecutionIsEnabled;
   bool myWantsExecutionStateEnabled;

   bool myAwaitingTaskFlag;

   DtRwUUID myPlanName;

   bool  myContinuePlan;

   DtPlanExecutor* myPlanExecutor;

   DtPlanStatus myLastSentStatus;
   
   DtRwInt myQuickLaunchFlags;
   DtRwString myQuickLaunchIcon;
   DtRwInt myOrdinal;

   DtRwIntegerList myExecutingTriggers;

   DtRwVariableBindings myPlanVariables;
};

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