rwUUID.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2022 MAK Technologies, Inc.
 * All rights reserved.
 ****************************************************************************/


#pragma once

#include "vrfutil/vrfutilDefines.h"
#include "readerWriter/readerWriter.h"
#include "readerWriter/rwString.h"
#include <vrfutil/asciiSerializable.h>
#include <boost/uuid/uuid.hpp>            
#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>

#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/serialization/access.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <boost/uuid/uuid_serialize.hpp>
#include <tbb/recursive_mutex.h>

class DtRwUUID;
class DtUUID;

class DT_DLL_vrfutil DtUUIDOwner
{
public:
   virtual void uuidChanged() = 0;
};

class DT_DLL_vrfutil DtUUIDMarkingTextProvider
{
public:
   virtual ~DtUUIDMarkingTextProvider() {};
   virtual DtString markingText() = 0;
   virtual DtUUIDMarkingTextProvider* clone() const = 0;

   operator DtString () { return markingText(); };
};

class DT_DLL_vrfutil DtMarkingTextStringProvider : public DtUUIDMarkingTextProvider
{
public:
   DtMarkingTextStringProvider(const DtString&);
   DtMarkingTextStringProvider(const DtMarkingTextStringProvider&);

   virtual ~DtMarkingTextStringProvider();

   virtual void setMarkingText(const DtString& s) { myMarkingText = s; };
   virtual DtString markingText() { return myMarkingText; };

   virtual DtUUIDMarkingTextProvider* clone() const;

protected:
   DtString myMarkingText;
};

class DT_DLL_vrfutil DtObjectIdentificationResolver
{
public:
   typedef boost::unordered_map<DtUUID, DtUUIDMarkingTextProvider*> UUIDToMarkingTextMap;
   typedef boost::unordered_map<DtString, DtUUID> EntityIdentifierToUUIDMap;
   typedef boost::unordered_map<DtUUID, DtString> UUIDToEntityIdentifierMap;
   typedef boost::unordered_map<DtString, DtUUID> MarkingTextToUUIDMap;
   typedef boost::unordered_map<DtUUID, DtUUID> UUIDToUUIDMap;
   typedef boost::unordered_map<DtString, DtString> MarkingTextToMarkingTextMap;
   typedef boost::unordered_set<DtUUID*> UUIDsForUpgrade;

   DtObjectIdentificationResolver();

   virtual ~DtObjectIdentificationResolver();

   virtual void clear();

   virtual void setResolveMarkingTextToUUIDMapping(bool);
   virtual bool resolveMarkingTextToUUIDMapping() const;

   virtual void setResolveUUIDToUUIDMapping(bool);

   virtual bool resolveUUIDToUUIDMapping() const;

   virtual void resolveUUIDMapping(bool clearWhenDone = false);

   virtual bool addUUIDForUpgrade(DtUUID*);
   virtual void removeUUIDForUpgrade(DtUUID*);

   virtual void objectUUIDChanged(const DtUUID& oldUUID, const DtUUID& newUUID);

   virtual DtUUIDMarkingTextProvider* addMarkingTextToUUIDMapping(const DtUUIDMarkingTextProvider&, const DtUUID&);
   virtual DtUUIDMarkingTextProvider* uuidToMarkingTextProvider(const DtUUID&) const;

   virtual void removeUUIDToMarkingTextMapping(const DtUUID&);

   virtual void addUUIDToUUIDMapping(const DtUUID& old, const DtUUID& newUUID);

   virtual void addEntityIdentifierToUUIDMapping(const DtString& eid, const DtUUID&);
   virtual void removeEntityIdentifierMapping(const DtString& eid);
   virtual const DtUUID& entityIdentifierToUUIDMapping(const DtString& eid) const;
   virtual const DtString& uuidToEntityIdentifierMapping(const DtUUID& uuid) const;

   virtual bool hasUUID(const DtUUID&) const;

   virtual void addMarkingTextToMarkingTextMapping(const DtString& oldMarkingText, const DtString& newMarkingText);

   virtual DtUUID mapMarkingTextToUUID(const DtString&) const;

   virtual bool hasMarkingText(const DtString&) const;

   virtual DtString mapUUIDToMarkingText(const DtUUID&) const;

   virtual void pushMappingContext();

   virtual void popMappingContext(bool merge = false);

   virtual DtString markingText(const DtUUID&, bool* found = 0) const;

   MarkingTextToUUIDMap& markingTextToUUIDMapForImport(int context = -1);
   const MarkingTextToUUIDMap& markingTextToUUIDMapForImport(int context = -1) const;

   MarkingTextToUUIDMap& liveMarkingTextToUUIDMap(int context = -1);
   const MarkingTextToUUIDMap& liveMarkingTextToUUIDMap(int context = -1) const;
   virtual void markingTextUpdated(const DtString& oldText, const DtString& newText);

   UUIDsForUpgrade& uuidsForMarkingTextUpgrade(int context = -1);
   const UUIDsForUpgrade& uuidsForMarkingTextUpgrade(int context = -1) const;

   UUIDsForUpgrade& uuidsForUUIDUpgrade(int context = -1);
   const UUIDsForUpgrade& uuidsForUUIDUpgrade(int context = -1) const;

   UUIDToMarkingTextMap& uuidToMarkingTextMap(int context = -1);
   const UUIDToMarkingTextMap& uuidToMarkingTextMap(int context = -1) const;

   UUIDToUUIDMap& uuidToUUIDMap(int context = -1);
   const UUIDToUUIDMap& uuidToUUIDMap(int context = -1) const;

   MarkingTextToMarkingTextMap& markingTextToMarkingTextMap(int context = -1);
   const MarkingTextToMarkingTextMap& markingTextToMarkingTextMap(int context = -1) const;

   EntityIdentifierToUUIDMap& entityIdentifierToUUIDMap(int context = -1);
   const EntityIdentifierToUUIDMap& entityIdentifierToUUIDMap(int context = -1) const;

   UUIDToEntityIdentifierMap& uuidToEntityIdentifierMap(int context = -1);
   const UUIDToEntityIdentifierMap& uuidToEntityIdentifierMap(int context = -1) const;

   MarkingTextToUUIDMap markingTextToUUIDMap() const;

   virtual void resolveToMarkingTextMapping();

   virtual void resolveToUUIDMapping(bool clearWhenDone = false);

   virtual DtUUID upgradeUUID(const DtUUID&) const;

   virtual bool hasMarkingTextToUUIDMapForImport(const DtString&) const;

protected:
   struct MappingContext
   {
      UUIDToMarkingTextMap myUUIDToMarkingTextMap;
      EntityIdentifierToUUIDMap myEntityIdentifierToUUIDMap;
      UUIDToEntityIdentifierMap myUUIDToEntityIdentifierMap;
      UUIDToUUIDMap myUUIDToUUIDMap;
      MarkingTextToMarkingTextMap myMarkingTextToMarkingTextMap;
      MarkingTextToUUIDMap myMarkingTextToUUIDMapForImport;
      MarkingTextToUUIDMap myMarkingTextToUUIDMap;

      UUIDsForUpgrade myUUIDsForMarkingTextUpgrade;
      UUIDsForUpgrade myUUIDsForUUIDUpgrade;
   };

   mutable tbb::recursive_mutex myMutex;

   typedef std::vector<MappingContext> MappingContexts;
   MappingContexts myMappingContexts;
   bool myDestructingFlag;

   mutable bool myResolveMarkingTextToUUIDMapping;
   mutable bool myResolveUUIDToUUIDMapping;
   mutable bool myPushingContext;
   mutable bool myPoppingContext;
};

class DT_DLL_vrfutil DtUUID : public DtAsciiSerializable
{
protected:
   enum UUIDType
   {
      NOTSET = 0,
      BOOST = 1,
      STRING = 2,
      UUIDSTRING = 3
   };

public:
   DtUUID(DtUUIDOwner* = 0);
   DtUUID(const DtUUID&, DtUUIDOwner* = 0);
   DtUUID(const boost::uuids::uuid&, DtUUIDOwner* = 0);

   explicit DtUUID(const DtString&, DtUUIDOwner* = 0, bool blockMarkingTextLookup = false);
   explicit DtUUID(const std::string&, DtUUIDOwner* = 0, bool blockMarkingTextLookup = false);
   explicit DtUUID(const char*, DtUUIDOwner* = 0, bool blockMarkingTextLookup = false);

   explicit DtUUID(const unsigned char* data, size_t dataLength, DtUUIDOwner* = 0);

   DtUUID& operator=(const DtUUID & orig);
   DtUUID& operator=(const boost::uuids::uuid & orig);
   bool operator<(const DtUUID & rhs) const;
   bool operator>(const DtUUID & rhs) const;

   virtual ~DtUUID();

   const char* data() const
   {
      return &myData[0];
   }

   unsigned int dataSize() const
   {
      return sizeof(myData);
   }

   void setBuffer(const char*);

   static bool isVrfUUID(const DtString&);

   bool isBoostUUID() const;
   bool isVrfUUID() const;

   UUIDType uuidType() const;

   virtual void setUUID(const DtString&, bool blockMarkingTextLookup = false);
   virtual const DtString& uuidString() const;

   static DtString uuidMarking();

   static DtUUID makeStringUUID(const DtString&);

   virtual void setMarkingText(const DtString&);

   virtual void setStringUUID(const DtString&);

   virtual void generateUUID();

   virtual void clearUUID();

   bool operator==(const DtString&) const;
   bool operator==(const std::string&) const;
   bool operator==(const char*) const;
   bool operator==(const DtUUID&) const;
   bool operator==(const DtRwUUID&) const;

   bool operator!=(const DtUUID& rhs) const { return !(*this == rhs); };
   bool operator!=(const DtString& rhs) const { return !(*this == rhs); };
   bool operator!=(const DtRwUUID& rhs) const { return !(*this == rhs); };

   virtual bool isValid() const;
   virtual bool isStringUUID() const;

   size_t hashValue() const;

   boost::uuids::uuid uuid() const
   {
      return asBoostUUID();
   }

   boost::uuids::uuid asBoostUUID() const;

   static const DtUUID& nullUUID();

   virtual DtString markingText() const;

   std::string string() const;

   static DtObjectIdentificationResolver& objectIdentificationResolver();

   //-------------------------------------------
   
   DtString objectType() const;

   DtString serialize();

   bool deserialize(const DtString& data);

   static DtAsciiSerializable* creator();

   static bool isValidBoostUUIDString(const DtString& str);

   virtual size_t calcHashValue() const;
   
   bool addedForUpgrade() const
   {
      return myAddedForUpgrade;
   }

   void setAddedForUpgrade(bool b)
   {
      myAddedForUpgrade = b;
   }

protected:
   friend class boost::serialization::access;

   template<class Archive>
      void serialize(Archive & ar, const unsigned int version)
   {
      if (Archive::is_loading::value)
      {
         std::string uuidS;

         ar & BOOST_SERIALIZATION_NVP(uuidS);

         setUUID(uuidS.c_str());
      }
      else
      {
         std::string uuidS = uuidString().c_str();

         ar & BOOST_SERIALIZATION_NVP(uuidS);
      }
   }

protected:
   virtual void convertStringToData(const std::string&);
   virtual boost::uuids::uuid convertToBoostUUID(const DtString&);
   virtual boost::uuids::uuid convertStringToBoostUUID(const DtString&, bool blockMarkingTextLookup = false);
   virtual const char* convertStringToStringUUID(const char* t) const;

protected:
   char myData[36];

   mutable DtString myUUIDString;

   DtString myMarkingText;
   DtUUIDOwner* myOwner;

   static DtObjectIdentificationResolver theObjectIdentificationResolver;

   size_t myHashValue;
   bool myAddedForUpgrade;
};

class DT_DLL_vrfutil DtRwUUID : public DtReaderWriter, public DtUUIDOwner
{
public:
   DtRwUUID();
   DtRwUUID(const char* name, DtReaderWriterRegistry* const parentRegistry = 0);
   DtRwUUID(const DtString& name, DtReaderWriterRegistry* const parentRegistry);
   DtRwUUID(const DtSymbolString& name, DtReaderWriterRegistry* const parentRegistry);

   DtRwUUID(const DtString& name, const DtRwUUID&, DtReaderWriterRegistry* const parentRegistry);
   DtRwUUID(const DtSymbolString& name, const DtRwUUID&, DtReaderWriterRegistry* const parentRegistry);
   DtRwUUID(const DtSymbolString& name, const DtUUID&, DtReaderWriterRegistry* const parentRegistry);
   DtRwUUID(const DtString& name, const DtUUID&, DtReaderWriterRegistry* const parentRegistry);
   DtRwUUID(const DtString& name, const char*, DtReaderWriterRegistry* const parentRegistry);
   DtRwUUID(const DtSymbolString& name, const char*, DtReaderWriterRegistry* const parentRegistry);
   DtRwUUID(const DtRwUUID&, DtReaderWriterRegistry* const parentRegistry);
   DtRwUUID(const DtRwUUID&);
   DtRwUUID(const DtUUID&);

   virtual ~DtRwUUID();

   virtual const char* readerWriterType() const;

   virtual void setMarkingText(const DtString&);
   virtual DtString markingText() const;

   static const char* theXmlType();

   operator const DtUUID& () const { return myUUID; };

   DtRwUUID& operator=(const DtRwUUID & orig);
   DtRwUUID& operator=(const DtUUID & orig);

   bool operator!=(const DtRwUUID & orig) const { return !(*this == orig); };
   bool operator==(const DtRwUUID & orig) const;

   bool operator<(const DtRwUUID & rhs) const { return myUUID < rhs; };
   bool operator>(const DtRwUUID & rhs) const { return myUUID > rhs; };

   virtual const char* xmlType() const
   {
      return theXmlType();
   }

   const DtUUID& uuid() const { return myUUID; };
   DtUUID& uuid() { return myUUID; };

   virtual void clearUUID();
   virtual DtString uuidString() const;
   virtual bool isValid() const;
   virtual void generateUUID();
   virtual void setUUID(const DtRwUUID& u);
   virtual void setUUID(const DtString& uuid);
   virtual void setStringUUID(const DtString& uuid);
   bool isVrfUUID() const;

   const char* data() const;

   unsigned int dataSize() const;
   void setBuffer(const char*);

   virtual DtlObjPtr getData(DtlObjPtr args, const SearchPaths& searchPaths,
      const DtVariableBindingsList& variableBindings);
   virtual void getSelf(DtlObjPtr args, const SearchPaths& searchPaths = DtReaderWriter::SearchPaths(),
      const DtVariableBindingsList& variableBindings = DtVariableBindingsList());
   virtual void getSelf(const DtEnvironmentSP env, const DtEnvValueSP root,
         const DtReaderWriter::SearchPaths& searchPaths = DtReaderWriter::SearchPaths(),
         const DtVariableBindingsList& varBindings = DtVariableBindingsList());
   virtual void getData(const DtEnvironmentSP, const DtEnvValueSP,
      const SearchPaths& searchPaths = SearchPaths(), 
      const DtVariableBindingsList& bindings = DtVariableBindingsList());
   virtual void putSelf(std::string& fp, int indentLevel = 0, 
      bool writeUnspecified = false, const DtFilename& path = 
      DtFilename::nullFilename());
   virtual void putSelf(DtEnvironmentSP env, DtEnvValueSP parent) const;
   virtual void putData(DtEnvironmentSP, DtEnvValueSP value) const;
   virtual void putData(std::string& fp, int);


   virtual DtString prettyPrint() const;

protected:
   virtual void noRwValueSpecified();

   virtual void uuidChanged();

protected:
   mutable DtUUID myUUID;
};

class DT_DLL_vrfutil DtRwObjectName : public DtRwUUID
{
public:
   DtRwObjectName();

   DtRwObjectName(const DtString& name, DtReaderWriterRegistry* const parentRegistry = NULL);
   DtRwObjectName(const DtSymbolString& name, DtReaderWriterRegistry* const parentRegistry = NULL);

   DtRwObjectName(const DtString& name, 
              const char* fromChars,
              DtReaderWriterRegistry* const parentRegistry = NULL);

   DtRwObjectName(const DtSymbolString& name, 
              const char* fromChars,
              DtReaderWriterRegistry* const parentRegistry = NULL);

   DtRwObjectName(const DtString& name, 
              const DtString& fromString, 
              DtReaderWriterRegistry* const parentRegistry = NULL);

   DtRwObjectName(const DtSymbolString& name, 
              const DtString& fromString, 
              DtReaderWriterRegistry* const parentRegistry = NULL);

   DtRwObjectName(const DtString& name, 
              const DtRwObjectName& fromString, 
              DtReaderWriterRegistry* const parentRegistry = NULL);

   DtRwObjectName(const DtSymbolString& name, 
              const DtRwObjectName& fromString, 
              DtReaderWriterRegistry* const parentRegistry = NULL);

   DtRwObjectName(const DtRwObjectName& orig, DtReaderWriterRegistry* const parentRegistry = NULL);

   DtRwObjectName& operator=(const DtRwObjectName & orig);
   DtRwObjectName& operator=(const DtUUID & orig);

   virtual ~DtRwObjectName();

   static const char* theXmlType();

   virtual const char* xmlType() const
   {
      return theXmlType();
   }
   
   virtual const char* readerWriterType() const;
};

DT_DLL_vrfutil std::size_t hash_value(DtUUID const& b);
DT_DLL_vrfutil std::size_t hash_value(DtString const& b);

namespace std
{
   template <>
   struct hash<DtUUID>
   {
      std::size_t operator()(const DtUUID& k) const
      {
         return k.hashValue();
      }
   };
}