uuid.hpp

Go to the documentation of this file.

//===- include/pstore/core/uuid.hpp -----------------------*- mode: C++ -*-===//
//*              _     _  *
//*  _   _ _   _(_) __| | *
//* | | | | | | | |/ _` | *
//* | |_| | |_| | | (_| | *
//*  \__,_|\__,_|_|\__,_| *
//*                       *
//===----------------------------------------------------------------------===//
//
// Part of the pstore project, under the Apache License v2.0 with LLVM Exceptions.
// See https://github.com/SNSystems/pstore/blob/master/LICENSE.txt for license
// information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef PSTORE_CORE_UUID_HPP
#define PSTORE_CORE_UUID_HPP

#include <array>
#include <cstdint>
#include <string>

#include "pstore/support/maybe.hpp"

#if defined(_WIN32)
#    define WIN32_LEAN_AND_MEAN
#    include <Rpc.h>
#elif defined(__APPLE__)
#    include <uuid/uuid.h>
#endif

namespace pstore {

    class uuid {
        friend bool operator== (uuid const & lhs, uuid const & rhs) noexcept;
        friend bool operator!= (uuid const & lhs, uuid const & rhs) noexcept;
        friend bool operator< (uuid const & lhs, uuid const & rhs) noexcept;
        friend bool operator<= (uuid const & lhs, uuid const & rhs) noexcept;
        friend bool operator> (uuid const & lhs, uuid const & rhs) noexcept;
        friend bool operator>= (uuid const & lhs, uuid const & rhs) noexcept;

    public:
        static constexpr auto elements = std::size_t{16};

        static constexpr auto string_length = elements * 2 + 4;

        using container_type = std::array<std::uint8_t, elements>;
        using value_type = container_type::value_type;
        using size_type = container_type::size_type;
        using difference_type = container_type::difference_type;

        using reference = container_type::reference;
        using const_reference = container_type::const_reference;
        using iterator = container_type::iterator;
        using const_iterator = container_type::const_iterator;

        uuid ();
        explicit uuid (std::string const & s);

        explicit constexpr uuid (container_type const & c)
                : data_{c} {}

#if defined(_WIN32)
        explicit uuid (UUID const & u);
#elif defined(__APPLE__)
        explicit uuid (uuid_t const & bytes);
#endif

        static maybe<uuid> from_string (std::string const & s);

        iterator begin () noexcept { return std::begin (data_); }
        const_iterator begin () const noexcept { return std::begin (data_); }
        iterator end () noexcept { return std::end (data_); }
        const_iterator end () const noexcept { return std::end (data_); }

        container_type const & array () const noexcept { return data_; }

        enum class variant_type {
            ncs,       // NCS backward compatibility
            rfc_4122,  // Defined by RFC 4122
            microsoft, // Microsoft Corporation backward compatibility
            future     // Future definition
        };
        enum class version_type {
            time_based = 1,
            dce_security = 2,
            name_based_md5 = 3,
            random_number_based = 4,
            name_based_sha1 = 5,
            unknown,
        };

        auto variant () const noexcept -> variant_type;
        auto version () const noexcept -> version_type;
        bool is_null () const noexcept;

        std::string str () const;

    private:
        container_type data_{};

        enum {
            version_octet = 6,
            variant_octet = 8,
        };

        template <typename Ty>
        static std::uint8_t get_byte (Ty const t, unsigned const num) noexcept {
            PSTORE_ASSERT (num < sizeof (Ty));
            return static_cast<std::uint8_t> ((t >> (num * 8)) & 0xff);
        }
    };

    PSTORE_STATIC_ASSERT (std::is_standard_layout<uuid>::value);
    PSTORE_STATIC_ASSERT (sizeof (uuid) == 16);

    std::ostream & operator<< (std::ostream & os, uuid::version_type v);
    std::ostream & operator<< (std::ostream & os, uuid::variant_type v);
    std::ostream & operator<< (std::ostream & os, uuid const & m);

    inline bool operator== (uuid const & lhs, uuid const & rhs) noexcept {
        return lhs.data_ == rhs.data_;
    }
    inline bool operator< (uuid const & lhs, uuid const & rhs) noexcept {
        return lhs.data_ < rhs.data_;
    }
    inline bool operator!= (uuid const & lhs, uuid const & rhs) noexcept {
        return lhs.data_ != rhs.data_;
    }
    inline bool operator> (uuid const & lhs, uuid const & rhs) noexcept {
        return lhs.data_ > rhs.data_;
    }
    inline bool operator<= (uuid const & lhs, uuid const & rhs) noexcept {
        return lhs.data_ <= rhs.data_;
    }
    inline bool operator>= (uuid const & lhs, uuid const & rhs) noexcept {
        return lhs.data_ >= rhs.data_;
    }

} // end namespace pstore

#endif // PSTORE_CORE_UUID_HPP