lgrDriver.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2025 MAK Technologies, Inc
** All rights reserved.
******************************************************************************/


#ifndef lgrDriver_H_
#define lgrDriver_H_

#include <lgrCore/lgrCore.h>
#include <lgrCore/lgrCommandDispatcher.h>
#include <lgrCmds/lgrCommand.h>
#include <lgrCmds/lgrCommandFunctor.h>
#include <lgrCmds/lgrRuntimeCommandFactory.h>

#include <vlutil/vlSmartPointers.h>
#include <vlutil/vlMutex.h>

#include <map>

class DtThread;

namespace MAKLogger
{

   class DtLgrSystemDriver;
   class DtCommandInterface;
   class DtRuntimeCommandFactory;
   class DtLgrCommandThread;

   class DT_DLL_LGRCORE DtLgrCommandHandler
   {
   public:

      DtLgrCommandHandler(const DtString& name,DtRuntimeCommandFactory*
         ,DtCommandDispatcherSP);

      virtual ~DtLgrCommandHandler();

      void lock();

      void unlock();

      virtual void tick() = 0;

      DtCommandDispatcherSP dispatcher();

      virtual const DtString& driverName() const;

      virtual const DtString& driverInfo();

      virtual void processCommand(const DtCommand& command);

      virtual bool releasePipeline() = 0;


      virtual bool getPipeline() = 0;

      virtual bool hasPipeline() const = 0;

      virtual bool spawnThread(DtLgrCommandThread* commandThread);

      virtual void stopAllThreads();

      virtual void stopThread( DtLgrCommandThread* commandThread );

   protected:

      void addCommandHandler(const DtCommandDefinition& commandDef,
         DtCommandFunctorSP commandFunctor);

      void removeCommandHandler(const DtCommandDefinition& commandDef);

      virtual void sendResponse(DtResponse response);

      virtual void queueResponse(DtResponse response);

      virtual void sendQueuedResponses();

      virtual void emptyResponseQueue();

      DtResponse finishThread(const DtCommand& command);

   protected:

      typedef DtLgrCommandHandler* (*DriverCreator)(DtCommandDispatcherSP);
      typedef std::map<DtLgrCommandId,DtCommandFunctorSP> DtLgrCommandHandlerMap;
      typedef std::map<DtString,DtLgrCommandId> DtLgrCommandNameMap;

      typedef std::list<DtResponse> DtResponseQueue;

      DtRuntimeCommandFactory* myRuntimeCommandFactory;

      DtLgrCommandHandlerMap myCommandMap;
      DtCommandDispatcherSP  myDispatcher;
      DtResponseQueue myResponseQueue;
      DtString myName;
      DtString myInfo;

      DtMutex myMutex;

      typedef std::map<DtLgrCommandThread*, DtThread*> CommandThreadMap;

      CommandThreadMap myRunningCommandThreads;

   };

   typedef std::shared_ptr<DtLgrCommandHandler> DtLgrCommandHandlerSP;

}

#endif