tb_uuid.hpp

 
#ifndef TurtleBrains_uuid_hpp
#define TurtleBrains_uuid_hpp
 
 
// @note 2023-11-08: While uuid doesn't itself need platform related stuff, the sole dependency is using platform stuff.
//   We are including this file to get "ahead" of the curve and include the platform stuff for the sole dependency in
//   order to not have issues with Windows defining min/max or other similar issues.
#include <turtle_brains/core/tb_platform.hpp>
#include <turtle_brains/core/tb_string.hpp>
#include <turtle_brains/core/tb_types.hpp>
 
#include <sole/sole.hpp>
 
#include <array>
 
namespace TurtleBrains::Core
{
    template<typename Type> class TypedUUID
    {
    public:
 
        // UUID v0, pro: unique; cons: MAC revealed, pid revealed, predictable.
        static TypedUUID Generate0(void) { TypedUUID value; value.mUUID = sole::uuid0(); return value; }
 
        // UUID v1, pro: unique; cons: MAC revealed, predictable.
        static TypedUUID Generate1(void) { TypedUUID value; value.mUUID = sole::uuid1(); return value; }
 
        // UUID v4, pros: anonymous, fast; con: uuids "can clash"
        static TypedUUID Generate4(void) { TypedUUID value; value.mUUID = sole::uuid4(); return value; }
 
        static TypedUUID Invalid(void) { return TypedUUID(0, 0); }
 
        static TypedUUID FromRawData(const std::array<tbCore::byte, 16>& uuidData) { return TypedUUID(uuidData); }
 
        TypedUUID(void) :
            mUUID(sole::rebuild(0, 0))
        {
        }
 
        explicit TypedUUID(const String& uuidString) :
            mUUID(sole::rebuild(uuidString))
        {
        }
 
        explicit TypedUUID(const tbCore::uint64& first64, const tbCore::uint64& last64) :
            mUUID(sole::rebuild(first64, last64))
        {
        }
 
        explicit TypedUUID(const std::array<tbCore::byte, 16>& uuidData) :
            mUUID(sole::rebuild(0, 0))
        {
            tbCore::uint64 first = 0;
            tbCore::uint64 last = 0;
            for (size_t index = 0; index < 8; ++index)
            {
                reinterpret_cast<tbCore::byte*>(&first)[index] = uuidData[index];
                reinterpret_cast<tbCore::byte*>(&last)[index] = uuidData[index + 8];
            }
 
            mUUID = sole::rebuild(first, last);
        }
 
        TypedUUID(const TypedUUID<Type>& other) :
            mUUID(other.mUUID)
        {
        }
 
        TypedUUID(TypedUUID<Type>&& other) noexcept :
            mUUID(sole::rebuild(0, 0))
        {
            std::swap(mUUID, other.mUUID);
        }
 
        ~TypedUUID(void)
        {
        }
 
        inline tbCore::String String(void) const { return tbCore::String(mUUID.str()); }
 
        inline std::array<tbCore::byte, 16> RawData(void) const
        {
            std::array<tbCore::byte, 16> data;
            for (size_t index = 0; index < 8; ++index)
            {
                data[index] = reinterpret_cast<const tbCore::byte*>(&mUUID.ab)[index];
                data[index + 8] = reinterpret_cast<const tbCore::byte*>(&mUUID.cd)[index];
            }
 
            return data;
        }
 
        inline TypedUUID& operator=(const TypedUUID& other)
        {
            mUUID = other.mUUID;
            return *this;
        }
 
        inline TypedUUID& operator=(TypedUUID&& other) noexcept
        {
            std::swap(mUUID, other.mUUID);
            return *this;
        }
 
        inline bool operator==(const TypedUUID& other) const { return mUUID == other.mUUID; }
        inline bool operator!=(const TypedUUID& other) const { return mUUID != other.mUUID; }
        inline bool operator<(const TypedUUID& other) const { return mUUID < other.mUUID; }
 
        template<typename ToType> friend class TypedUUID;
        template<typename ToType> explicit operator TypedUUID<ToType>() const
        {
            TypedUUID<ToType> value;
            value.mUUID = mUUID;
            return value;
        }
 
        friend inline std::ostream& operator<<(std::ostream& output, const TypedUUID<Type>& object)
        {
            return output << object.String();
        }
 
        friend std::istream& operator>>(std::istream& input, TypedUUID<Type>& data)
        {
            tbCore::String temporaryString;
            input >> temporaryString;
            data.mUUID = sole::rebuild(temporaryString);
            return input;
        }
 
    private:
        // @note: 2023-12-17: I attempted to add a debug string to make debugging support much better, since it is
        //   very easy to confuse the String vs the UUID when debugging, the two values will never match and it makes
        //   things painful, forcing dev to use temporary code to grab the string. However, adding that string here
        //   changes the size of the UUID object which is saved/loaded to binary files as POD, and adding a string
        //   breaks that...
        sole::uuid mUUID;
    };
 
    enum class DefaultKeyType {};
    using uuid = TypedUUID<DefaultKeyType>;
 
}; /* namespace TurtleBrains::Core */
 
namespace tbCore = TurtleBrains::Core;
 
//--------------------------------------------------------------------------------------------------------------------//
 
// 2025-11-09: This fixes an issue where std::unordered_map<TypedUUID<Type>> would complain about the std::hash not being
//   defined/usable. It does have to be in global space to work.
template<typename Type> struct std::hash<tbCore::TypedUUID<Type>>
{
    std::size_t operator()(const tbCore::TypedUUID<Type>& uuid) const noexcept
    {
        return std::hash<std::string>{}(TurtleBrains::Core::ToString(uuid));
    }
};
 
#endif /* TurtleBrains_uuid_hpp */