lgrCommand.h

Go to the documentation of this file.

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


#pragma once

#include <lgrCmds/lgrCmds.h>

#include <lgrUtil/runtimeValue.h>
#include <lgrUtil/lgrExceptions.h>
#include <vlutil/vlString.h>
#include <vlutil/vlSmartPointers.h>
#include <map>

namespace MAKLogger
{

   typedef unsigned char DtLgrDomainId;
   typedef unsigned char DtLgrProtocolId;
   typedef short DtLgrCommandId;

   class DT_DLL_LGR_CMDS DtLgrCommandType
   {
   public:


      static const DtLgrDomainId Domain_Invalid    = 0;
      static const DtLgrDomainId Domain_System     = 1;
      static const DtLgrDomainId Domain_Player     = 2;
      static const DtLgrDomainId Domain_Recorder   = 3;
      static const DtLgrDomainId Domain_Editor     = 4;
      static const DtLgrDomainId Domain_Simulation = 5;
      static const DtLgrDomainId Domain_Shared     = 6;
      static const DtLgrDomainId Domain_UserStart  = 20;

      static const int theLgrDomainStringsCount;
      static const char * const theLgrDomainStrings[];

      static DtLgrDomainId lookupDomain(const DtString& name);


      static const DtLgrProtocolId Protocol_Invalid   = 0;
      static const DtLgrProtocolId Protocol_None      = 1;
      static const DtLgrProtocolId Protocol_DIS       = 2;
      static const DtLgrProtocolId Protocol_HLA_13    = 3;
      static const DtLgrProtocolId Protocol_HLA_1516  = 4;
      static const DtLgrProtocolId Protocol_HLA_1516E = 5;
      static const DtLgrProtocolId Protocol_TENA      = 6;
      static const DtLgrProtocolId Protocol_HLA_4     = 7;
      static const DtLgrProtocolId Protocol_Undefined = 8;
      //@]


      static const int theLgrProtocolsStringsCount;
      static const char* theLgrProtocolsStrings[];

      static DtLgrProtocolId lookupProtocol(const DtString& name);

      static DtString lookupProtocolName(DtLgrProtocolId protocolId);

      DtLgrCommandType();

      DtLgrCommandType(DtLgrDomainId aDomain,DtLgrProtocolId aProtocol);

      DtLgrCommandType(const DtLgrCommandType& type);

      DtLgrDomainId    domain();
      DtLgrProtocolId  protocol();

      bool operator==(const DtLgrCommandType& secondType) const;

      bool operator!=(const DtLgrCommandType& secondType) const;

      bool operator<(const DtLgrCommandType& secondType) const;

      bool operator>(const DtLgrCommandType& secondType) const;

      DtString toString();

   public:
      static const char* domainToString(int domainValue);
      static const char* protocolToString(int protocolValue);

   protected:
      DtLgrDomainId   myDomain;
      DtLgrProtocolId myProtocol;
   };

   template<>
   DT_DLL_LGR_CMDS int DtValue<DtLgrCommandType>::theTypeId();


   typedef std::shared_ptr<DtAnyValue>      DtAnyValueSP;
   typedef std::map<DtString,DtAnyValueSP>      DtCommandParams;
   typedef std::shared_ptr<DtCommandParams> DtCommandParamsSP;

   class DT_DLL_LGR_CMDS DtCommand
   {
   public:

      DtCommand(DtLgrDomainId domain,DtLgrProtocolId protocol,DtLgrCommandId command,
         const char* parametersBuffer=0);

      DtCommand(DtLgrDomainId domain,DtLgrProtocolId protocol,const DtString& commandName);

      DtCommand(const DtLgrCommandType& type,DtLgrCommandId command);

      DtCommand(const DtCommand& type);

      ~DtCommand();

      DtLgrCommandType type() const;

      DtLgrCommandId id() const;

      void setId(DtLgrCommandId id);

      const DtString* name() const;

      void setParameter(const DtString& name,DtAnyValue*);

      const DtAnyValue* parameter(const DtString& name) const;

      void serializeParameters(DtString& parameterBuffer) const;

      void deserializeParameters(const char* parameterBuffer);

      static const DtLgrCommandId theUnknownCommand = 0;

      bool operator==(const DtCommand&) const;
      bool operator!=(const DtCommand&) const;
      bool operator<(const DtCommand&) const;
      bool operator>(const DtCommand&) const;

   protected:
      DtLgrCommandType  myType;
      DtLgrCommandId    myCommand;
      DtCommandParamsSP myParameters;
      DtString*         myUnknownCommandName;
   };

   typedef std::shared_ptr<DtCommand>       DtCommandSP;
   //typedef const DtCommand                    DtCommandConst;
   typedef std::shared_ptr<const DtCommand> DtResponse;

   #define DT_FACTORY_COMMAND(commandName,createParams,decodeParams)\
      static DtCommandDefinition  define##commandName##Command();\
      static DtCommand create##commandName##Command createParams;\
      static void decode##commandName##Command decodeParams;

   #define DT_FACTORY_COMMAND_EXT(commandId,commandName,createParams,decodeParams)\
      static const DtLgrCommandId Command_##commandName = commandId;\
      static DtCommandDefinition  define##commandName##Command();\
      static DtCommand create##commandName##Command createParams;\
      static void decode##commandName##Command decodeParams;


   #define DT_FACTORY_RESPONSE(responseName,createParams,decodeParams)\
      static DtResponse create##responseName##Response createParams;\
      static void decode##responseName##Response decodeParams;



   #define DT_FACTORY_RESPONSE_EXT(responseId,responseName,createParams,decodeParams)\
      static const DtLgrCommandId Response_##responseName = responseId;\
      static DtResponse create##responseName##Response createParams;\
      static void decode##responseName##Response decodeParams;


   template <typename ValueType>
   void DtGetCommandParameter(const DtCommand& command,const DtString& name,ValueType& value);

   template <typename ValueType>
   void DtGetResponseParameter(const DtResponse response,const DtString& name,ValueType& value);

   #define lgrCommand_INC_
   #include "lgrCommand.inl"
   #undef lgrCommand_INC_
}