UUID.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants
Licensee a limited, non-exclusive, non-transferable, royalty-free license
(without the right to sublicense) to use the API solely for the purpose of
Licensee's internal development efforts to develop applications for which
the API was provided.
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: UUID
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/Vector.h>
#include <NDEVR/BufferBase.h>
#include <NDEVR/StringView.h>
namespace NDEVR
{
    class StringView;
 
    class UUID : public Vector<16, uint01>
    {
    public:
        constexpr UUID()
            : Vector<16, uint01>(Constant<uint01>::Invalid)
        {}

        constexpr explicit UUID(const Vector<16, uint01>& bytes) noexcept
            : Vector<16, uint01>(bytes)
        {}

        explicit UUID(const uint01& other) noexcept
            : Vector<16, uint01>(0)
        {
            *this = appendUUID(other);
        }

        explicit UUID(const uint02& other) noexcept
            : Vector<16, uint01>(0)
        {
            *this = appendUUID(other);
        }

        explicit UUID(const uint04& other) noexcept
            : Vector<16, uint01>(0)
        {
            *this = appendUUID(other);
        }

        explicit UUID(const uint08& other) noexcept
            : Vector<16, uint01>(0)
        {
            *this = appendUUID(other);
        }

        explicit UUID(const sint01& other) noexcept
            : Vector<16, uint01>(0)
        {
            *this = appendUUID(other);
        }

        explicit UUID(const sint02& other) noexcept
            : Vector<16, uint01>(0)
        {
            *this = appendUUID(other);
        }

        explicit UUID(const sint04& other) noexcept
            : Vector<16, uint01>(0)
        {
            *this = appendUUID(other);
        }

        explicit UUID(const sint08& other) noexcept
            : Vector<16, uint01>(0)
        {
            *this = appendUUID(other);
        }

        explicit UUID(const fltp04& other) noexcept
            : Vector<16, uint01>(0)
        {
            *this = appendUUID(other);
        }

        explicit UUID(const fltp08& other) noexcept
            : Vector<16, uint01>(0)
        {
            *this = appendUUID(other);
        }

 
        NDEVR_BASE_API uint01* getUniquePointer() const;

 
        NDEVR_BASE_API static UUID CreateUUID();

        NDEVR_BASE_API static constexpr UUID CreateUUID(const StringView& identifier)
        {
            UUID id = UUID(Constant<Vector<16, uint01>>::Invalid);
            uint01 i = 0;
            for (uint04 n = 0; n < identifier.size(); n++)
            {
                id[i] = id[i] ^ identifier[n];
                i = (i + 1) % 16;
            }
            return id;
        }

        [[nodiscard]] NDEVR_BASE_API UUID appendBoolUUID(bool offset) const;

        [[nodiscard]] NDEVR_BASE_API UUID appendUUID(const StringView& identifier) const;

        [[nodiscard]] NDEVR_BASE_API UUID appendUUID(uint04 offset) const;

        [[nodiscard]] NDEVR_BASE_API UUID appendUUID(uint08 offset) const;

        [[nodiscard]] NDEVR_BASE_API UUID appendUUID(sint04 offset) const;

        [[nodiscard]] NDEVR_BASE_API UUID appendUUID(sint08 offset) const;

        [[nodiscard]] NDEVR_BASE_API UUID appendUUID(fltp04 offset) const;

        [[nodiscard]] NDEVR_BASE_API UUID appendUUID(const Vector<3, fltp04>& offset) const;

        [[nodiscard]] NDEVR_BASE_API UUID appendUUID(fltp08 offset) const;

        [[nodiscard]] NDEVR_BASE_API UUID appendUUID(const UUID& offset) const;

        template<uint01 t_size, class t_type>
        [[nodiscard]] UUID appendUUID(const Vector<t_size, t_type>& offset) const
        {
            UUID id(*this);
            for (uint01 i = 0; i < t_size; i++)
                id = id.appendUUID(offset[i]);
            return id;
        }

        template<size_t t_size, class t_type>
        [[nodiscard]] UUID appendUUID(const t_type(&value)[t_size])
        {
            UUID id(*this);
            for (uint01 i = 0; i < t_size; i++)
                id = id.appendUUID(value[i]);
            return id;
        }

        template<size_t t_size>
        [[nodiscard]] UUID appendUUID(const char(&value)[t_size])
        {
            return appendUUID(StringView(value));
        }

        constexpr size_t hash() const
        {
            std::size_t value = 0;
            for (uint01 i = 0; i < 8; i++)
            {
                value = value * 256 + ((*this)[i + 0] ^ (*this)[i + 8]);
            }
            return value;
        }

        constexpr size_t operator()() const
        {
            return hash();
        }

        bool operator<(const UUID& other) const
        {
            for (uint01 i = 0; i < 16; i++)
            {
                if ((*this)[i] == other[i])
                    continue;
                return (*this)[i] < other[i];
            }
            return false;
        }

        bool operator<=(const UUID& other) const
        {
            for (uint01 i = 0; i < 16; i++)
            {
                if ((*this)[i] == other[i])
                    continue;
                return (*this)[i] < other[i];
            }
            return true;
        }

        bool operator>(const UUID& other) const
        {
            for (uint01 i = 0; i < 16; i++)
            {
                if ((*this)[i] == other[i])
                    continue;
                return (*this)[i] > other[i];
            }
            return false;
        }

        bool operator>=(const UUID& other) const
        {
            for (uint01 i = 0; i < 16; i++)
            {
                if ((*this)[i] == other[i])
                    continue;
                return (*this)[i] > other[i];
            }
            return true;
        }
    };

    template<>
    struct ObjectInfo<UUID, true, false>
    {
        static const uint01 Dimensions = 16; 
        static const bool Vector = true;     
        static const bool Buffer = false;    
        static const bool Primitive = true;  
        static const bool Pointer = false;   
        static const bool Unsigned = false;  
        static const bool Float = false;     
        static const bool Integer = false;   
        static const bool Number = false;    
        static const bool Enum = false;      
        static const bool String = true;     
        static const bool Color = false;     
        static const bool Boolean = false;   

        static constexpr ObjectInfo<uint01, false, false> VectorSub() { return ObjectInfo<uint01, false, false>(); }
    };
    template<> constexpr const UUID Constant<UUID>::Invalid = UUID(Constant<Vector<16, uint01>>::Invalid); 
    template<> constexpr const UUID Constant<UUID>::Max = UUID(Constant<Vector<16, uint01>>::Max);         
    template<> constexpr const UUID Constant<UUID>::Min = UUID(Constant<Vector<16, uint01>>::Min);         
}
namespace std//Define things to allow use within std libs
{
    template <>
    struct hash<NDEVR::UUID>
    {
        std::size_t operator()(const UUID& s) const noexcept
        {
            std::size_t value = 0;
            for (uint01 i = 0; i < 8; i++)
            {
                value = value * 256 + (s[i + 0U] ^ s[i + 8U]);
            }
            return value;
        }
    };
};
#ifdef _MSC_VER
    //Used to help debugging
    namespace natvis
    {
        struct x4lo { unsigned __int8 v : 4;    unsigned __int8 _ : 4; }; 
        struct x4hi { unsigned __int8 _ : 4;    unsigned __int8 v : 4; }; 
        struct x8 { unsigned __int8 _; };  
        struct x32 { __int32 _; }; 
    }
#endif