UUID.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/String.hpp"
 
#include <cstdlib>
#include <cstring>
#include <iosfwd>
#include <random>
#include <tuple>
 
namespace CeresEngine {
 
    struct CE_SCRIPT_EXPORT(storage = "value") UUID {
        CE_SCRIPT_EXPORT(readonly = true)
        UInt32 raw[4] = {0, 0, 0, 0}; // NOLINT
 
        CE_SCRIPT_EXPORT()
        constexpr UUID() = default;
 
        CE_SCRIPT_EXPORT()
        constexpr UUID(const UInt32 data1, const UInt32 data2, const UInt32 data3, const UInt32 data4) : raw{data1, data2, data3, data4} {}
 
        CE_SCRIPT_EXPORT()
        explicit UUID(StringView uuid);
 
        explicit UUID(const char* uuid) : UUID(StringView(uuid, strlen(uuid))){};
 
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT()
        constexpr bool empty() const { return raw[0] == 0 && raw[1] == 0 && raw[2] == 0 && raw[3] == 0; }
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        String toString() const;
 
        void toString(String& str) const;
 
    public:
        void copyTo(Byte* buffer) const { memcpy(buffer, &raw[0], sizeof(raw[0]) * 4); }
 
        void copyFrom(const Byte* buffer) { memcpy(&raw[0], buffer, sizeof(raw[0]) * 4); }
 
    public:
        friend constexpr bool operator==(const UUID& lhs, const UUID& rhs) noexcept {
            return lhs.raw[0] == rhs.raw[0] && lhs.raw[1] == rhs.raw[1] && lhs.raw[2] == rhs.raw[2] && lhs.raw[3] == rhs.raw[3];
        }
 
        friend constexpr bool operator!=(const UUID& lhs, const UUID& rhs) noexcept { return !(lhs == rhs); }
 
        friend constexpr bool operator<(const UUID& lhs, const UUID& rhs) noexcept {
            return lhs.raw[0] < rhs.raw[0] && lhs.raw[1] < rhs.raw[1] && lhs.raw[2] < rhs.raw[2] && lhs.raw[3] < rhs.raw[3];
        }
 
        friend constexpr bool operator>(const UUID& lhs, const UUID& rhs) noexcept { return rhs < lhs; }
 
        friend constexpr bool operator<=(const UUID& lhs, const UUID& rhs) noexcept { return !(rhs < lhs); }
 
        friend constexpr bool operator>=(const UUID& lhs, const UUID& rhs) noexcept { return !(lhs < rhs); }
 
        friend String toString(const UUID& uuid) { return uuid.toString(); }
 
        friend std::ostream& operator<<(std::ostream& os, const UUID& uuid);
    
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT()
        static UUID random();
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        static UUID withNamespace(const UUID& ns, StringView name);
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        static UUID fromName(StringView name);
 
        template<typename Generator> static UUID random(Generator generator) { return UUID{generator(), generator(), generator(), generator()}; }
    };
 
} // namespace CeresEngine
 
template<> struct std::hash<CeresEngine::UUID> {
    size_t operator()(const CeresEngine::UUID& value) const {
        using CeresEngine::hash;
        return hash(value.raw[0], value.raw[1], value.raw[2], value.raw[3]);
    }
};