lgrRuntimeCommandFactory.h

Go to the documentation of this file.

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


#ifndef lgrRuntimeCommandFactory_H_
#define lgrRuntimeCommandFactory_H_

#include "lgrCore.h"
#include "lgrCommand.h"

#include "collectors.h"

#include <map>
#include <list>

class DtString;

namespace MAKLogger
{

   typedef std::pair<DtString,DtString>     DtNamedTypedParameter;

   typedef std::list<DtNamedTypedParameter> DtParameterList;

   //Define a command Unique Id as its type and id
   typedef std::pair<DtLgrCommandType,DtLgrCommandId> DtLgrCommandUniqueId;

   typedef std::pair<DtString,DtParameterList> DtCommandAttributes;
   typedef std::pair<DtLgrCommandUniqueId,DtCommandAttributes> DtCommandDefinitionPair;

   class DT_DLL_LGRCORE DtCommandDefinition
   {
   public:
      DtCommandDefinition(DtLgrCommandType,DtLgrCommandId,DtString,
         bool commandLine = true);

      DtLgrCommandType type() const;
      DtLgrCommandId id() const;

      void setUniqueId(DtLgrCommandType,DtLgrCommandId);
      DtLgrCommandUniqueId uniqueId() const;

      void setName(const DtString&);
      DtString name() const;

      DtParameterList& parameters();
      const DtParameterList& parameters() const;

      bool accessViaCommandLine() const;

   protected:
      bool myAccessViaCommandLine;
      DtCommandDefinitionPair myDefinition;
   };

   class DT_DLL_LGRCORE DtRuntimeCommandFactory
   {
   public:

      DtRuntimeCommandFactory();
      virtual ~DtRuntimeCommandFactory();

      virtual void commandNames(DtCollector<DtString> names);

      virtual void commandParams(DtLgrCommandType,DtLgrCommandId,
         DtParameterList& outParams);

      virtual DtString* commandName(DtLgrCommandType,DtLgrCommandId);

      DtLgrCommandType commandType(const DtString& name);

      virtual DtLgrCommandId commandId(const DtString&);

      virtual DtCommand generateCommand(DtLgrCommandType type,
         DtLgrCommandId id,const DtParameterList& nameValuePairs);

      DtAnyValue* deserializeParameter(const DtString& type,const DtString& value) const;

      DtAnyValue* deserializeParameterList(const DtString& type,const std::vector<DtString>& values) const;

      void registerCommand(const DtCommandDefinition&);

      void unregisterCommand(const DtCommandDefinition&);

      static bool isListType(const DtString&);

      static DtString listItemType(const DtString listType);

      static DtString baseType(const DtString typeAlias);

      static DtString stringType();
      static DtString intType();
      static DtString int64Type();
      static DtString floatType();
      static DtString doubleType();
      static DtString boolType();
      static DtString timeType();
      static DtString stringListType();
      static DtString voidPtrType();
      static DtString base64Type();

   protected:

      virtual bool isStringType(const DtString& type) const;
      virtual bool isIntType(const DtString& type) const;
      virtual bool isInt64Type(const DtString& type) const;
      virtual bool isFloatType(const DtString& type) const;
      virtual bool isDoubleType(const DtString& type) const;
      virtual bool isBoolType(const DtString& type) const;
      virtual bool isTimeType(const DtString& type) const;
      virtual bool isStringListType(const DtString& type) const;      
      virtual bool isVoidPtrType(const DtString& type) const;
      virtual bool isBase64Type(const DtString& type) const;

      typedef std::map<DtLgrCommandUniqueId,DtParameterList> DtCommandParamMap;
      typedef std::map<DtLgrCommandUniqueId,DtString>        DtCommandIdMap;
      typedef std::map<DtString,DtLgrCommandUniqueId>  DtCommandNameMap;

      DtCommandNameMap myCommandNameMap;

      DtCommandIdMap   myCommandIdMap;

      DtCommandParamMap myCommandParamMap;

   };

}

#endif