datatypeManager.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 1992-2024 MAK Technologies, Inc
** All rights reserved.
*******************************************************************************/
#pragma once



#pragma warning(disable : 4100)

#include "datatypeRep.h"

#define UNDEFINED_STR "---"

#include <map>
#include <vlutil/vlString.h>
#include <vector>
#include <list>
#include <mtl/mtl.h>
#include <mtl/mtlEnvironment.h>
class DtOMTTree;
class DtOMTNode;
class DtOMTDatatypeNode;
class DtObjectClassFedNode;
class DtInteractionClassFedNode;
class DtComplexComponentNode;
class DtComplexDatatypeNode;
class DtArrayDatatypeNode;
class DtDatatypeFedNode;
class DtStringTree;
class DtObjectHistory;

//shortcut
#define theOMTDatatypeManager DtDatatypeManager::defaultInstance()

class DT_DLL_OMTREADER DtDatatypeManager
{
public:

   enum DtDatatypeEnum { 
      SIMPLE = 1,          
      ENUMERATED,          
      COMPLEX,             
      ARRAY,               
      VARIANT,             
      FIXED,               
      DEFINED,             
      UNDEFINED,           
      DATATYPE_MAX
   };

   static DtDatatypeManager* defaultInstance();

   DtDatatypeManager();

   virtual ~DtDatatypeManager();

   virtual void initOMTData(DtOMTTree* omtTree);

   virtual DtOMTTree* omtTree() {return myOMTTree;};

   virtual void setImplicitPadding(bool enableImplicitPadding);
   virtual bool isImplicitPaddingEnabled() const;

//--- The following functions are used to setup the representation list ---

   virtual void fillDefaultDatatypeRepList();

   //Fill in more representations manually. Note that this datatype
   //now gets owned by this function and takes care of deleting it.
   virtual void addDatatypeRep(DtDatatypeRep*);

   //This is a special type of Mapping
   virtual void addDefinedDatatypeRep(DtDatatypeRep*);

   //Returns the class representation of a datatype. This only works with simple
   //Reps since more complicated datatypes build the string out of multiple representations.
   virtual DtDatatypeRep* getSimpleDatatypeRep(const DtString& datatypeName);

   virtual std::map<DtString,DtDatatypeRep*>::iterator getNameRepMapList();
   virtual std::map<DtString,DtDatatypeRep*>::iterator getNameRepMapListEnd();


   //--- The following functions are used to setup the delimiter mappings ---

   // For example, if the delimiter is :. Then a location(x,y,z) would look
   virtual void addDelimiterMap(const DtString& datatype, const DtString& delimiter);
   virtual void removeDelimiterMap(const DtString& datatype);

   virtual void setDefaultDelimiter(const DtString& str);

   virtual void setArrayWrapper(const DtString& start, const DtString& end);

   virtual DtString getDelimiterMap(const DtString& datatypeName, bool* isAvailable = 0);
   virtual std::map<DtString,DtString>::iterator getDelimiterList();
   virtual std::map<DtString,DtString>::iterator getDelimiterListEnd();

   //--- The following functions are used to setup the array bracket mappings ---

   virtual void addArrayBracketMap(const DtString& datatype, bool valueIsBracketed);
   virtual void removeArrayBracketMap(const DtString& datatype);

   virtual void setDefaultArrayBracket(bool valueIsBracketed);

   virtual bool getArrayBracketMap(const DtString& datatypeName, bool* isAvailable = 0);
   virtual std::map<DtString,bool>::iterator getArrayBracketList();
   virtual std::map<DtString,bool>::iterator getArrayBracketListEnd();

   //--- The following functions are used to setup the representation to datatype mappings ---


   virtual void readFile(DtString str);

   virtual void writeFile(DtString str);

   //Add a mapping between a datatype and a representation
   virtual void addRepMapping(const DtString& datatype, const DtString& rep);
   virtual void removeRepMapping(const DtString& datatype);

   //Add a mapping between an attribute Name and a representation
   virtual void addAttributeMapping(const DtString& datatype, const DtString& rep);
   virtual void removeAttributeMapping(const DtString& datatype);
   virtual const DtString& attributeMapping(const DtString& attributeName) const;

   virtual bool modifyRepMapping(const DtString& datatype, const DtString& rep);

   virtual std::map<DtString,DtString>::iterator getRepMapList();
   virtual std::map<DtString,DtString>::iterator getRepMapListEnd();

   //--- The following functions are used to convert objects to their representation ---

   virtual DtString getFedNodeStringRep(const DtDatatypeFedNode* currFedNode, 
      const void* value, int size, int& returnSize);
   virtual DtString getStringRep(const DtString& datatypeName, 
      const void* value, int size, int& returnSize);
   virtual DtString getStringRep(const DtOMTDatatypeNode& datatypeNode, 
      const void* value, int size, int& returnSize);
   
   virtual DtStringTree* createStringTreeRep(const DtDatatypeFedNode* currFedNode,
      const void* value, int size, int& returnSize, unsigned int currentOffset = 0,
      DtObjectHistory* = 0);
   virtual DtStringTree* createStringTreeRep(const DtString& datatypeName, 
      const void* value, int size, int& returnSize, const DtOMTNode* omtNode = 0,
      unsigned int currentOffset = 0, DtStringTree* strParentTree = 0,
      DtObjectHistory* = 0);
   virtual DtStringTree* createStringTreeRep(const DtOMTDatatypeNode& datatypeNode, 
      const void* value, int size, int& returnSize,
      unsigned int currentOffset = 0, DtStringTree* strParentTree = 0,
      DtObjectHistory* = 0);
      
   virtual void getValueFromStringRep(const DtString& datatypeName, const DtString& stringRep,
      std::vector<char>& result);

   virtual DtString convertStringTreeToString (DtStringTree*, const DtString& delimiter);


   //--- The following functions are used to gather extra information about a datatype ---

   //Find what type of datatype an item is (Simple, Enum, Complex, etc)
   virtual DtDatatypeEnum getDatatypeEnum(const DtString& datatypeName);
   
   // and FOM have been made to mappings
   virtual bool isDirty();

   virtual void setIsDirty(bool makeDirty);

protected:

   DtDatatypeManager(const DtDatatypeManager& orig);

   DtDatatypeManager& operator=(const DtDatatypeManager& rhs);

   virtual DtDatatypeRep* repNameToDatatypeRep(DtString const& name);

   virtual bool getRepresentationName(DtString const& datatypeName, DtString& repName);


   virtual void checkOrphanMappings();
   virtual void checkObjOrphans(DtObjectClassFedNode* objClass);
   virtual void checkIntOrphans(DtInteractionClassFedNode* intClass);

   virtual void getDefaultRep(const void* value, int size, int& returnSize, DtString& returnString);
   virtual void getDatatypeRep(const DtString& datatypeName, const void* value, int size, int& returnSize, DtString& returnString);
   virtual void getAttributeRep(const DtString& attributeName, const void* value, int size, int& returnSize, DtString& returnString);
   virtual void getEnumRep(const DtString& datatypeName, const void* value, int size, int& returnSize, DtString& returnString);
   virtual void getVariantRep(const DtString& datatypeName, const void* value, int size, int& returnSize, DtString& returnString);
   virtual void getArrayRepBySize(const DtString& datatypeName, const void* value, int size, int& returnSize, DtString& returnString);
   virtual void getArrayRepByCount(DtArrayDatatypeNode* arrayNode, const void* value, int size, int& returnSize, DtString& returnString);
   virtual void getArrayRep(const DtString& datatypeName, const void* value, int size, int& returnSize, DtString& returnString);

   virtual void getValueFromDatatypeRep(const DtString& datatypeName, const DtString& stringRep, std::vector<char>& result);
   virtual void getValueFromArrayRep(const DtString& datatypeName, const DtString& stringRep, std::vector<char>& result);
   virtual void getValueFromComplexRep(const DtString& datatypeName, const DtString& stringRep, std::vector<char>& result);
   virtual void getValueFromFixedRep(const DtString& datatypeName, const DtString& stringRep, std::vector<char>& result);
   virtual void getValueFromEnumRep(const DtString& datatypeName, const DtString& stringRep, std::vector<char>& result);

   virtual void createComplexTreeRep(
      const DtString& datatypeName,  const void* value, int size, 
      int& returnSize, DtStringTree* strTree, DtStringTree* strParentTree = 0,
      unsigned int currentOffset = 0,
      DtObjectHistory* = 0);
   virtual void createArrayTreeRep(
      const DtString& datatypeName,  const void* value, int size, 
      int& returnSize, DtStringTree* strTree, DtStringTree* strParentTree = 0,
      unsigned int currentOffset = 0,
      DtObjectHistory* = 0);
   virtual void createDefinedTreeRep(
      const DtString& datatypeName,  const void* value, int size, 
      int& returnSize, DtStringTree* strTree, DtStringTree* strParentTree = 0,
      unsigned int currentOffset = 0,
      DtObjectHistory* = 0);
   virtual void createVariantTreeRep(
      const DtString& datatypeName,  const void* value, int size, 
      int& returnSize, DtStringTree* strTree, DtStringTree* strParentTree = 0,
      unsigned int currentOffset = 0,
      DtObjectHistory* = 0);
   virtual void createFixedTreeRep(
      const DtString& datatypeName,  const void* value, int size, 
      int& returnSize, DtStringTree* strTree, DtStringTree* strParentTree = 0,
      unsigned int currentOffset = 0,
      DtObjectHistory* = 0);
   
   virtual void processMappings(DtlObjPtr& ptr);

   virtual int getComplexDatatypeCount(DtComplexComponentNode* compNode, DtComplexDatatypeNode* parentNode,
      const void* value, int valueSize, int alreadyRead,
      const DtStringTree* strTree = 0, const DtStringTree* parentTree = 0);

   virtual int getArrayDatatypeCount(DtArrayDatatypeNode* arrayNode,
      const void* value, int valueSize, 
      const DtStringTree* strTree = 0, const DtStringTree* parentTree = 0);
 
   virtual int byteAlignment(const DtString& datatype);
   virtual int byteAlignmentFromRep(const DtString& datatype);
   virtual int byteAlignmentFixed(const DtString& datatype);
   virtual int byteAlignmentArray(const DtString& datatype);
   virtual int byteAlignmentVariant(const DtString& datatype);
   virtual int byteAlignmentComplex(const DtString& datatype);
   virtual int implicitPadding(unsigned int currentOffset, const DtString& datatypeName);

protected:

   DtOMTTree* myOMTTree;
   std::map<DtString,DtDatatypeEnum> myDatatypeTypeMap;

   typedef std::map<DtString,DtString> DatatypeNameRepNameMap;
   DatatypeNameRepNameMap myDatatypeToRepMap;
   DatatypeNameRepNameMap myAttributeToRepMap;
   std::set<DtString> myRemappedDatatypes;


   typedef std::map<DtString,DtDatatypeRep*> RepNamePtrMap; 
   RepNamePtrMap myNameToRepMap;

   DtString myDefaultDelimiter;
   std::map<DtString,DtString> myDelimiterMap;
   DtString myStartWrapper;
   DtString myEndWrapper;

   DtString myDefaultArrayBracket;
   std::map<DtString,bool> myArrayBracketMap;

   bool myUseImplicitPadding;

   bool myDirty;
   std::set<DtString> myUnknownDatatypes;

   static DtDatatypeManager* theDatatypeManager;


};