remoteBatchManager.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2002 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: remBatchMgr.h,v $ $Revision: 1.14 $ $State: Exp $
*******************************************************************************/


#ifndef DtRemoteBatchManager_H_
#define DtRemoteBatchManager_H_

#include <vlutil/vlMachineTypes.h>
#include <vlutil/vlFilename.h>
#include <vlutil/vlTime.h>
#include <vlutil/vlList.h>

#include "vrfcontrol/vrfRemoteController.h"

class DtScenarioBatchIterator;
class DtRemoteLoggerController;
class DtExerciseConn;
class DtClock;
class DtScenario;
class DtScenarioBatch;

typedef void (*DtScenarioCallbackFcn)(void *usr);

#include "vrfcontrol/vrfcontrolDefines.h"
class DT_DLL_vrfcontrol DtRemoteBatchManager
{
   enum State
   {
      StateIdle,
      StateRunStart,
      StateLoading,
      StateRunning,
      StateRunComplete,
      StateRunBatchComplete,
      StateErrorLoading,
      StateClosing,
   };

public:
   DtRemoteBatchManager(DtVrfRemoteController *controller, 
      DtExerciseConn* exConn);
   virtual ~DtRemoteBatchManager();

   virtual bool init();

   virtual bool loadBatch(const DtFilename &batchFileName, 
      DtBackendRemappingFcn fcn = NULL, void* userData = NULL);
   virtual bool loadBatch(const DtScenarioBatch &batch, 
      DtBackendRemappingFcn fcn = NULL, void* userData = NULL);
   virtual bool runBatch();
   virtual bool stopBatch();
   virtual bool running();
   virtual bool done();

   virtual const DtScenarioBatchIterator* batchIterator();

   virtual void processBackendsLoadedCallback();

   virtual void addScenarioLoadingCallback(DtScenarioCallbackFcn fcn, void* usr);
   virtual void removeScenarioLoadingCallback(DtScenarioCallbackFcn fcn, void* usr);

   virtual void addScenarioLoadingErrorCallback(DtScenarioCallbackFcn fcn, void* usr);
   virtual void removeScenarioLoadingErrorCallback(DtScenarioCallbackFcn fcn, void* usr);

   virtual void addScenarioBatchCompleteCallback(DtScenarioCallbackFcn fcn, void* usr);
   virtual void removeScenarioBatchCompleteCallback(DtScenarioCallbackFcn fcn, void* usr);

   virtual void addScenarioClosingCallback(DtScenarioCallbackFcn fcn, void* usr);
   virtual void removeScenarioClosingCallback(DtScenarioCallbackFcn fcn, void* usr);

   virtual void processScenarioCallbacksForState(const State &state);

   virtual void removeCallbacksFor(DtScenarioCallbackFcn fcn, void* usrData, const State state);

   virtual void nextScenarioRun();

   virtual void nextScenario();

   virtual void idle();

   virtual void scheduleNextRun();

public:

   static void tickCb(void* usr);

   static void backendsLoadedCallback(void *usr);

protected:
   DtRemoteBatchManager();
   DtRemoteBatchManager(const DtRemoteBatchManager &orig);
   DtRemoteBatchManager& operator=(const DtRemoteBatchManager &orig);

   virtual DtFilename constructLoggerFilename(const DtScenario* scenario);

   virtual void tick();

   virtual double currentSimulationTime() const;

protected:
   DtExerciseConn* myExConn;
   DtScenarioBatchIterator *myBatchIterator;
   DtRemoteLoggerController *myLoggerControl;
   DtVrfRemoteController *myRemoteController;
   DtClock *myClock;
   
   State myState;
   bool myRunning;
   bool myDone;
   DtTime myRunStartTime;
   bool myBackendsLoaded;

   DtList myCallbacks;
   
   DtBackendRemappingFcn myRemappingFcn;
   void* myRemappingFcnUserData;
};

#endif