uuid.h

Go to the documentation of this file.

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


#pragma once

#include "vrfutil/vrfutilDefines.h"
#include <vrfutil/asciiSerializable.h>
#include <boost/uuid/uuid.hpp>            
#include <vlutil/vlUuid.h>
#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>

class DtObjectIdentificationResolver;

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() override { return myMarkingText; };

   virtual DtUUIDMarkingTextProvider* clone() const override;

protected:
   DtString myMarkingText;
};

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

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

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

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

   DtUUID& operator=(const DtUUID & orig);
   DtUUID& operator=(const boost::uuids::uuid & orig);
   DtUUID& operator=(const DtVrlUuid&);
   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 void setUUID(const DtVrlUuid&);
   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();

   virtual DtVrlUuid vrlUuid() const;

   bool operator==(const DtString&) const;
   bool operator==(const std::string&) const;
   bool operator==(const char*) const;
   bool operator==(const DtUUID&) const;
   bool operator==(const DtVrlUuid&) 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); };
   bool operator!=(const DtVrlUuid& 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 override;

   DtString serialize() override;

   bool deserialize(const DtString& data) override;

   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;
};

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

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