UUID.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
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/ObjectInfo.h>
 
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    \brief A universally unique identifier (UUID) is a 128-bit number used to identify information in 
        computer systems. The term globally unique identifier (GUID) is also used.
 
    UUIDs are for practical purposes unique, without depending for their uniqueness on a central 
    registration authority or coordination between the parties generating them, unlike most other 
    numbering schemes. While the probability that a UUID will be duplicated is not zero, it is 
    close enough to zero to be negligible.
 
    Thus, anyone can create a UUID and use it to identify something with near certainty that 
    the identifier does not duplicate one that has already been, or will be, created to identify 
    something else. Information labeled with UUIDs by independent parties can therefore be later 
    combined into a single database, or transmitted on the same channel, without needing 
    to resolve conflicts between identifiers.
    
    Author: Tyler Parke
    
    Date: 2017-11-17
    **/
 
    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 bool& other) noexcept
            : Vector<16, uint01>(0)
        {
            *this = appendUUID(other);
        }
        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);
        }
 
        /**--------------------------------------------------------------------------------------------------
                Gets unique pointer.
        
        Author: Tyler Parke
        
        Date: 2017-11-17
        
        \returns Null if it fails, else the unique pointer.
        **/
 
        NDEVR_BASE_API uint01* getUniquePointer() const;
 
        /**--------------------------------------------------------------------------------------------------
                Creates the uuid.
        
        Author: Tyler Parke
        
        Date: 2017-11-17
        
        \returns The new uuid.
        **/
 
        NDEVR_BASE_API static UUID CreateUUID();
        NDEVR_BASE_API static constexpr UUID CreateUUID(const char* identifier)
        {
            UUID id = UUID(Constant<Vector<16, uint01>>::Invalid);
            uint01 i = 0;
            while (*identifier)
            {
                id[i] = id[i] ^ *identifier;
                i = (i + 1) % 16;
                identifier++;
            }
            return id;
        }
        [[nodiscard]] NDEVR_BASE_API UUID appendUUID(bool offset) const;
        [[nodiscard]] NDEVR_BASE_API UUID appendUUID(const char* 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;
        }
        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 NDEVR::UUID& s) const noexcept
        {
            std::size_t value = 0;
            for (NDEVR::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; }; // NOLINT(clang-diagnostic-language-extension-token)
        struct x4hi { unsigned __int8 _ : 4;    unsigned __int8 v : 4; }; // NOLINT(clang-diagnostic-language-extension-token)
        struct x8 { unsigned __int8 _; };  // NOLINT(clang-diagnostic-language-extension-token)
        struct x32 { __int32 _; }; // NOLINT(clang-diagnostic-language-extension-token)
    }
#endif