lgrSystemDriver.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
******************************************************************************/


#ifndef lgrSystemDriver_H_
#define lgrSystemDriver_H_

#include "lgrCore.h"
#include "lgrCommand.h"
#include "lgrCommandDispatcher.h"
#include "lgrDriver.h"
#include "lgrExceptions.h"
#include "lgrRuntimeCommandFactory.h"
#include "virtualConstructor.h"
#include "threadSafe.h"

#include <map>
#include <set>
#include <list>

namespace MAKLogger
{

   class DtLgrDynamicLibrary;
   class DtLgrSystemCommandFactory;
   class DtLogger;
   class DtMessagePipeline;
   class DtRuntimeCommandFactory;
   class DtLgrProtocolRegistration;
   class DtLgrSimManager;
   typedef std::list<DtBoost::shared_ptr<DtLgrDynamicLibrary> > DtLibraryList;

   class DT_DLL_LGRCORE DtLgrSystemDriver
   {
   public:
      typedef DtLgrSystemCommandFactory Factory;

      enum NasmpMode
      {
         NasmpMode_None,
         NasmpMode_Snnf
      };

      enum NasmpFlag
      {
         NasmpFlag_Fast
      };

   public:
      DT_VIRTUAL_CTR(DtLgrSystemDriver,(DtLogger&))

      
      virtual ~DtLgrSystemDriver();

      virtual void tick();

      void init(DtLgrProtocolRegistration*);

      virtual bool timeToShutdown() const;

      virtual void submitCommand(const DtCommand& command);

      DtCommandDispatcherSP dispatcher();

      DtMessagePipeline* requestPipeline(DtLgrCommandHandler*);

      bool releasePipeline();

      const DtLgrCommandHandler* pipelineOwner() const;

      const DtMessagePipeline* pipeline() const;

      void setPipelineDriver(DtLgrDomainId domain);

      void addDriver(DtLgrCommandType, DtLgrCommandHandlerSP driver);

      DtLgrCommandHandlerSP getCommandHandler(const DtLgrCommandType& type);

      bool removeDriver(DtLgrCommandType type);

      void setSimManager(DtLgrSimManager*);

      const DtLgrSimManager* simManager() const;

      DtLgrSimManager* simManager();

      virtual void loadPluginLibrary(const DtString& filename);

      void setNotifyLevel(int vlLevel,int lgrLevel);

      void setBasicGuiFlag(bool basic);

      void issueTextCommand(const DtString& textCommand);

      void setEntityTracking(bool enableEntityTracking);

      bool entityTracking() const;

      void setFastJumpsWithoutDiff(bool enableFastJumpsWithoutDiff);

      bool fastJumpsWithoutDiff() const;

      void setPlaybackReadTimeLimit(double readTimeLimit);

      double playbackReadTimeLimit() const;

      void setNasmpMode (const DtString& nasmpMode);

      int  notifyLevel() const;

      bool basicGuiFlag()const;

      DtString nasmpModeString() const;

      NasmpMode nasmpMode() const;

      bool nasmpFlag(NasmpFlag flag);

      void sendMessage(const DtString& message);

      DtRuntimeCommandFactory* runtimeCommandFactory();

      const DtLibraryList&  libraries() const;


      DtLogger* logger();
      const DtLogger* logger() const;

      DtThreadSafe<bool>* cancelLongOperationFlag();

      void startLongOperation(const DtString& name,bool interruptible);

      void updateLongOperation(const DtString& message,int progress);

      void finishLongOperation();

      void cancelLongOperation();

      bool isLongOperationCanceled() const;

   protected:
      DtResponse shutdownCommand(const DtCommand& command);
      DtResponse cancelShutdown(const DtCommand& command);
      DtResponse createDriver(const DtCommand& command);
      DtResponse loadPlugin(const DtCommand& command);
      DtResponse setNotifyLevel(const DtCommand& command);
      DtResponse setBasicGuiFlag(const DtCommand& command);
      DtResponse setPlaybackReadTimeLimit(const DtCommand& command);
      DtResponse setEntityTracking(const DtCommand& command);
      DtResponse setFastJumpsWithoutDiff(const DtCommand& command);
      DtResponse setNasmpMode(const DtCommand& command);
      DtResponse deleteFile(const DtCommand& command);
      DtResponse installOutputListener(const DtCommand& command);
      DtResponse issueTextCommand(const DtCommand& command);
      DtResponse helpCommand(const DtCommand& command);
      DtResponse infoCommand(const DtCommand& command);
      DtResponse setTempDir(const DtCommand& command);
      DtResponse setDefaultTapeDirectory(const DtCommand& command);


   protected:
      //Type definitions
      typedef DtU32 NasmpFlags;

      static const int NasmpModeMask   = 0x0f;
      static const int NasmpModeNone   = 0x00;
      static const int NasmpModeSnnf   = 0x01;

      static const int NasmpFlagMask   = 0xf0;
      static const int NasmpFlagFast   = 0x10;

      typedef DtResponse (DtLgrSystemDriver::*CommandHandler)(const DtCommand&);
      typedef std::map<DtLgrCommandId,CommandHandler>  DtCommandMap;
      typedef std::map<DtLgrCommandType,DtLgrCommandHandlerSP> DtDriverMap;
      typedef std::set<DtLgrCommandHandlerSP> DtDriverList;

      virtual void unloadLibraries();

      void registerCommandHandler(const DtCommandDefinition&,CommandHandler);

      virtual void tickDrivers();

      virtual void lockDrivers();

      virtual void unlockDrivers();

      virtual void processCommands();

      virtual DtString commandDescription( const DtString& commandName) const;

      void lookupCommandId(DtCommand& command);

      virtual void processCommand(const DtCommand& command);

   protected:
      DtLogger* myParentLogger;

      DtCommandMap         myCommandMap;
      DtDriverList          myDriverList;
      DtDriverMap           myDriverMap;
      DtCommandDispatcherSP myDispatcher;
      DtMessagePipeline*    myPipeline;
      DtLgrCommandHandler*  myPipelineOwner;

      DtLgrSimManager* mySimManager;

      DtRuntimeCommandFactory* myRuntimeCommandFactory;

      DtLibraryList myLibraries;

      bool myShutdownFlag;

      bool myBasicGuiFlag;

      DtString myNasmpMode;

      bool myEntityTracking;

      bool myFastJumpsWithoutDiff;

      DtMutex myCommandHandlerMutex;

      DtThreadSafe<bool> myCancelLongOperationFlag;

      NasmpFlags myNasmpFlags;
   };

}

#endif