uuid.hpp

Go to the documentation of this file.

 
#ifndef ELEC_C7222_BLE_GATT_UUID_H_
#define ELEC_C7222_BLE_GATT_UUID_H_
 
#include <algorithm>
#include <array>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <ostream>
 
#include <bluetooth_gatt.h>  // For BTstack defined UUIDs
namespace c7222 {
 
class Uuid {
   public:
    enum class Type : uint8_t {
        Invalid = 0,
        k16Bit = 1,
        k128Bit = 2
    };
 
    enum class AttributeType : uint16_t {
        kPrimaryServiceDeclaration = 0x2800,
        kSecondaryServiceDeclaration = 0x2801,
        kIncludedServiceDeclaration = 0x2802,
        kCharacteristicDeclaration = 0x2803,
        kServerCharacteristicConfiguration = 0x2903,
        kClientCharacteristicConfiguration = 0x2902,
        kCharacteristicUserDescription = 0x2901,
        kCharacteristicExtendedProperties = 0x2900,
        kCharacteristicPresentationFormat = 0x2904,
        kCharacteristicAggregateFormat = 0x2905
    };
    Uuid() = default;
 
    Uuid(const Uuid&) = default;
 
    Uuid(Uuid&&) noexcept = default;
 
    Uuid& operator=(const Uuid&) = default;
 
    Uuid& operator=(Uuid&&) noexcept = default;
 
    explicit Uuid(uint16_t uuid16) : type_(Type::k16Bit) {
        auto* ptr = reinterpret_cast<uint8_t*>(&uuid16);
        std::fill(uuid_.begin(), uuid_.end(), 0);
        std::copy(ptr, ptr + sizeof(uuid16), uuid_.begin());
    }
 
    Uuid(const uint8_t* uuid, size_t size);
 
    explicit Uuid(const std::array<uint8_t, 16>& uuid) : type_(Type::k128Bit), uuid_(uuid) {}
 
    explicit Uuid(const std::array<uint8_t, 2>& uuid) : type_(Type::k16Bit) {
        std::copy(uuid.begin(), uuid.end(), uuid_.begin());
    }
 
    [[nodiscard]] Type type() const {
        return type_;
    }
 
    [[nodiscard]] bool Is16Bit() const {
        return type_ == Type::k16Bit;
    }
 
    [[nodiscard]] bool Is128Bit() const;
 
    [[nodiscard]] bool IsValid() const {
        return type_ != Type::Invalid;
    }
 
    [[nodiscard]] uint16_t Get16Bit() const {
        assert(type_ == Type::k16Bit && "UUID is not 16-bit");
        uint16_t ret;
        auto* ptr = reinterpret_cast<uint8_t*>(&ret);
        std::copy(uuid_.begin(), uuid_.begin() + 2, ptr);
        return ret;
    }
 
    [[nodiscard]] const std::array<uint8_t, 16>& Get128Bit() const {
        assert(type_ == Type::k128Bit && "UUID is not 128-bit");
        return uuid_;
    }
 
    [[nodiscard]] const uint8_t* data() const {
        return uuid_.data();
    }
 
    static Uuid Convert16To128(const Uuid& uuid16);
 
    // ========== GATT Attribute Type Helpers ==========
    // These helpers return false for non-16-bit/custom UUIDs.
 
    static Uuid PrimaryServiceDeclaration();
 
    static Uuid SecondaryServiceDeclaration();
 
    static Uuid IncludedServiceDeclaration();
 
    static Uuid CharacteristicDeclaration();
 
    static Uuid ClientCharacteristicConfiguration();
 
    static Uuid ServerCharacteristicConfiguration();
 
    static Uuid CharacteristicUserDescription();
 
    static Uuid CharacteristicExtendedProperties();
 
    static Uuid CharacteristicPresentationFormat();
 
    static Uuid CharacteristicAggregateFormat();
 
    static bool IsPrimaryServiceDeclaration(const Uuid& uuid);
 
    static bool IsSecondaryServiceDeclaration(const Uuid& uuid);
 
    static bool IsIncludedServiceDeclaration(const Uuid& uuid);
 
    static bool IsCharacteristicDeclaration(const Uuid& uuid);
 
    static bool IsServiceDeclaration(const Uuid& uuid);
 
    static bool IsClientCharacteristicConfiguration(const Uuid& uuid);
 
    static bool IsServerCharacteristicConfiguration(const Uuid& uuid);
 
    static bool IsCharacteristicUserDescription(const Uuid& uuid);
 
    static bool IsCharacteristicExtendedProperties(const Uuid& uuid);
 
    static bool IsDescriptor(const Uuid& uuid);
 
    bool operator==(const Uuid& other) const;
 
    bool operator!=(const Uuid& other) const {
        return !(*this == other);
    }
 
    friend std::ostream& operator<<(std::ostream& os, const Uuid& uuid);
 
   private:
    Type type_ = Type::Invalid;
    std::array<uint8_t, 16> uuid_{};
};
 
std::ostream& operator<<(std::ostream& os, const Uuid& uuid);
 
}  // namespace c7222
 
#endif  // ELEC_C7222_BLE_GATT_UUID_H_