uuid.hpp

Go to the documentation of this file.

//
// Created by spak on 9/26/21.
//
 
#ifndef LIBGULLIBLE_UUID_HPP
#define LIBGULLIBLE_UUID_HPP
 
#include <array>
#include <ble/nimble_host_guard.hpp>
#include <mlab/any_of.hpp>
 
namespace ble {
 
    constexpr std::array<uint8_t, 16> base_uuid = {
            0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
            0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
    enum struct uuid_type : std::uint8_t {
        _16 = BLE_UUID_TYPE_16,
        _32 = BLE_UUID_TYPE_32,
        _128 = BLE_UUID_TYPE_128
    };
 
    template <uuid_type>
    struct uuid_data {
    };
 
    template <std::size_t Size>
    struct uuid_data_with_length {
        std::array<std::uint8_t, Size> d{};
 
        uuid_data_with_length() = default;
 
        inline explicit uuid_data_with_length(std::array<std::uint8_t, Size> d_);
    };
 
    template <>
    struct uuid_data<uuid_type::_16> : public uuid_data_with_length<2> {
        using uuid_data_with_length<2>::uuid_data_with_length;
 
        inline explicit uuid_data(std::uint16_t d_);
 
        [[nodiscard]] inline std::uint16_t to_nimble() const;
 
        [[nodiscard]] inline std::array<std::uint8_t, 16> expand() const;
    };
 
    template <>
    struct uuid_data<uuid_type::_32> : public uuid_data_with_length<4> {
        using uuid_data_with_length<4>::uuid_data_with_length;
 
        inline explicit uuid_data(std::uint32_t d_);
 
        [[nodiscard]] inline std::uint32_t to_nimble() const;
 
        [[nodiscard]] inline std::array<std::uint8_t, 16> expand() const;
    };
 
    template <>
    struct uuid_data<uuid_type::_128> : public uuid_data_with_length<16> {
        using uuid_data_with_length<16>::uuid_data_with_length;
    };
 
    template <uuid_type>
    struct uuid_cast_t {
    };
 
    static constexpr auto cast_uuid16 = uuid_cast_t<uuid_type::_16>{};
    static constexpr auto cast_uuid32 = uuid_cast_t<uuid_type::_32>{};
    static constexpr auto cast_uuid128 = uuid_cast_t<uuid_type::_128>{};
 
    class uuid : public mlab::any_of<uuid_type, uuid_data> {
    public:
        uuid();
 
        uuid(uuid const &other);
 
        uuid &operator=(uuid const &other);
 
        uuid(std::initializer_list<std::uint8_t> data);
 
        uuid(uuid_cast_t<uuid_type::_16>, std::uint16_t data);
 
        uuid(uuid_cast_t<uuid_type::_32>, std::uint32_t data);
 
        explicit uuid(std::array<std::uint8_t, 2> data);
 
        explicit uuid(std::array<std::uint8_t, 4> data);
 
        explicit uuid(std::array<std::uint8_t, 16> data);
 
        uuid(uuid_cast_t<uuid_type::_16>, std::initializer_list<std::uint8_t> data);
 
        uuid(uuid_cast_t<uuid_type::_32>, std::initializer_list<std::uint8_t> data);
 
        uuid(uuid_cast_t<uuid_type::_128>, std::initializer_list<std::uint8_t> data);
 
        uuid(uuid &&) noexcept = default;
 
        uuid &operator=(uuid &&) noexcept = default;
 
        [[nodiscard]] static uuid from_nimble(ble_uuid_t const &ble_uuid);
 
        [[nodiscard]] static uuid from_nimble(ble_uuid16_t const &ble_uuid);
 
        [[nodiscard]] static uuid from_nimble(ble_uuid32_t const &ble_uuid);
 
        [[nodiscard]] static uuid from_nimble(ble_uuid128_t const &ble_uuid);
 
        [[nodiscard]] static uuid from_nimble(ble_uuid_any_t const &ble_uuid);
 
        [[nodiscard]] ble_uuid_any_t to_nimble() const;
 
        [[nodiscard]] bool operator==(uuid const &other) const;
 
        [[nodiscard]] bool operator!=(uuid const &other) const;
 
        [[nodiscard]] uuid as_uuid128() const;
 
        [[nodiscard]] std::string to_string() const;
    };
 
}// namespace ble
 
namespace ble {
 
    template <std::size_t Size>
    uuid_data_with_length<Size>::uuid_data_with_length(std::array<std::uint8_t, Size> d_) : d{d_} {}
 
    uuid_data<uuid_type::_16>::uuid_data(std::uint16_t d_)
        : uuid_data{{std::uint8_t(d_ & 0xff), std::uint8_t((d_ >> 8) & 0xff)}} {}
 
    uuid_data<uuid_type::_32>::uuid_data(std::uint32_t d_)
        : uuid_data{{std::uint8_t(d_ & 0xff), std::uint8_t((d_ >> 8) & 0xff),
                     std::uint8_t((d_ >> 16) & 0xff), std::uint8_t((d_ >> 24) & 0xff)}} {}
 
    std::uint16_t uuid_data<uuid_type::_16>::to_nimble() const {
        return std::uint16_t(d[0]) | (std::uint16_t(d[1]) << 8);
    }
 
    std::uint32_t uuid_data<uuid_type::_32>::to_nimble() const {
        return std::uint16_t(d[0]) | (std::uint16_t(d[1]) << 8) | (std::uint16_t(d[2]) << 16) |
               (std::uint16_t(d[3]) << 24);
    }
 
    std::array<std::uint8_t, 16> uuid_data<uuid_type::_16>::expand() const {
        auto new_d = base_uuid;
        new_d[12] = d[0];
        new_d[13] = d[1];
        return new_d;
    }
 
    std::array<std::uint8_t, 16> uuid_data<uuid_type::_32>::expand() const {
        auto new_d = base_uuid;
        new_d[12] = d[0];
        new_d[13] = d[1];
        new_d[14] = d[2];
        new_d[15] = d[3];
        return new_d;
    }
}// namespace ble
#endif//LIBGULLIBLE_UUID_HPP