attribute.hpp

Go to the documentation of this file.

 
#ifndef ELEC_C7222_BLE_GATT_ATTRIBUTE_H_
#define ELEC_C7222_BLE_GATT_ATTRIBUTE_H_
 
#include <functional>
#include <iostream>
#include <string>
#include <vector>
 
#include "ble_error.hpp"
#include "non_copyable.hpp"
#include "uuid.hpp"
 
namespace c7222 {
 
class Attribute : public MovableOnly {
   public:
 
    enum class Properties : std::uint16_t {
        kNone = 0x0000,
        kWritePermissionBit0 = 0x0001,
        kRead = 0x0002,
        kWriteWithoutResponse = 0x0004,
        kWrite = 0x0008,
        kWritePermissionBit1 = 0x0010,
        kReadPermissionSc = 0x0020,
        kAuthenticatedSignedWrite = 0x0040,
        kWritePermissionSc = 0x0080,
        kDynamic = 0x0100,
        kUuid128 = 0x0200,
        kReadPermissionBit0 = 0x0400,
        kReadPermissionBit1 = 0x0800,
        kEncryptionKeySizeMask = 0xF000
    };
 
    using ReadCallback = std::function<uint16_t(uint16_t offset, uint8_t* buffer, uint16_t buffer_size)>;
 
    using WriteCallback = std::function<BleError(uint16_t offset, const uint8_t* data, uint16_t size)>;
 
 
    static bool IsPrimaryServiceDeclaration(const Attribute& attr);
 
    static bool IsSecondaryServiceDeclaration(const Attribute& attr);
 
    static bool IsServiceDeclaration(const Attribute& attr);
 
    static bool IsIncludedServiceDeclaration(const Attribute& attr);
 
    static bool IsCharacteristicDeclaration(const Attribute& attr);
 
    static bool IsClientCharacteristicConfiguration(const Attribute& attr);
 
    static bool IsServerCharacteristicConfiguration(const Attribute& attr);
 
    static bool IsCharacteristicUserDescription(const Attribute& attr);
 
    static bool IsCharacteristicExtendedProperties(const Attribute& attr);
 
    static bool IsDescriptor(const Attribute& attr);
 
 
    static Attribute PrimaryServiceDeclaration(const Uuid& service_uuid, uint16_t handle = 0);
 
    static Attribute SecondaryServiceDeclaration(const Uuid& service_uuid, uint16_t handle = 0);
 
    static Attribute IncludedServiceDeclaration(uint16_t start_handle,
                                                uint16_t end_handle,
                                                const Uuid& service_uuid,
                                                uint16_t handle = 0);
 
    static Attribute CharacteristicDeclaration(uint8_t properties,
                                               uint16_t value_handle,
                                               const Uuid& characteristic_uuid,
                                               uint16_t handle = 0);
 
    static Attribute ClientCharacteristicConfiguration(uint16_t value, uint16_t handle = 0);
 
    static Attribute ServerCharacteristicConfiguration(uint16_t value, uint16_t handle = 0);
 
    static Attribute CharacteristicUserDescription(const std::string& description,
                                                   uint16_t handle = 0);
 
    static Attribute CharacteristicExtendedProperties(uint16_t value, uint16_t handle = 0);
 
    static Attribute CharacteristicPresentationFormat(uint8_t format,
                                                      int8_t exponent,
                                                      uint16_t unit,
                                                      uint8_t name_space,
                                                      uint16_t description,
                                                      uint16_t handle = 0);
 
    static Attribute CharacteristicAggregateFormat(const std::vector<uint16_t>& handles,
                                                   uint16_t handle = 0);
 
 
    Attribute() = default;
    
    Attribute(Attribute&&) noexcept = default;
 
    Attribute& operator=(Attribute&&) noexcept = default;
 
    Attribute(const Uuid& uuid, uint16_t properties, uint16_t handle = 0);
    Attribute(const Uuid& uuid, uint16_t properties, const uint8_t* data, size_t size, uint16_t handle = 0);
 
 
    [[nodiscard]] uint16_t GetHandle() const {
        return handle_;
    }
 
    void SetHandle(uint16_t handle) {
        handle_ = handle;
    }
 
    [[nodiscard]] const Uuid& GetUuid() const {
        return uuid_;
    }
 
    [[nodiscard]] bool IsUuid128() const {
        return uuid_.Is128Bit();
    }
 
    [[nodiscard]] bool IsValid() const {
        return handle_ != 0 && uuid_.IsValid();
    }
 
    [[nodiscard]] bool IsThisAttribute(const Uuid& uuid) const {
        return uuid_ == uuid;
    }
 
    [[nodiscard]] bool IsThisAttribute(uint16_t handle) const {
        return handle != 0 && handle_ == handle;
    }
 
    [[nodiscard]] bool IsThisAttribute(const Uuid& uuid, uint16_t handle) const {
        return uuid_ == uuid && handle_ == handle;
    }
 
 
    [[nodiscard]] uint16_t GetProperties() const {
        return properties_;
    }
 
    void SetProperties(uint16_t properties) {
        properties_ = properties;
        UpdateUuidProperty();
    }
 
 
    [[nodiscard]] const std::vector<uint8_t>& GetDynamicValue() const {
        return dynamic_value_;
    }
 
    [[nodiscard]] const uint8_t* GetValueData() const {
        if((properties_ & static_cast<uint16_t>(Properties::kDynamic)) != 0) {
            return dynamic_value_.empty() ? nullptr : dynamic_value_.data();
        }
        return static_value_ptr_;
    }
 
    [[nodiscard]] size_t GetValueSize() const {
        if((properties_ & static_cast<uint16_t>(Properties::kDynamic)) != 0) {
            return dynamic_value_.size();
        }
        return static_value_size_;
    }
 
    bool SetValue(const uint8_t* data, size_t size);
 
    bool SetStaticValue(const uint8_t* data, size_t size);
 
    bool SetValue(std::vector<uint8_t>&& data);
 
    bool SetValue(const std::vector<uint8_t>& data);
 
    bool SetStaticValue(const std::vector<uint8_t>& data);
 
    template<typename T>
    bool SetValue(const T& value) {
        static_assert(std::is_trivial<T>::value,
            "T must be a trivial type for binary conversion");
        return SetValue(reinterpret_cast<const uint8_t*>(&value), sizeof(T));
    }
 
 
    void SetReadCallback(ReadCallback callback) {
        read_callback_ = std::move(callback);
    }
 
    [[nodiscard]] bool HasReadCallback() const {
        return static_cast<bool>(read_callback_);
    }
 
    uint16_t InvokeReadCallback(uint16_t offset, uint8_t* buffer, uint16_t buffer_size) const;
 
    void SetWriteCallback(WriteCallback callback) {
        write_callback_ = std::move(callback);
    }
 
    [[nodiscard]] bool HasWriteCallback() const {
        return static_cast<bool>(write_callback_);
    }
 
    BleError InvokeWriteCallback(uint16_t offset, const uint8_t* data, uint16_t size);
 
 
    friend std::ostream& operator<<(std::ostream& os, const Attribute& attr);
 
   private:
    void UpdateUuidProperty() {
        if(uuid_.Is128Bit()) {
            properties_ |= static_cast<uint16_t>(Properties::kUuid128);
        } else {
            properties_ &= ~static_cast<uint16_t>(Properties::kUuid128);
        }
    }
 
    // ========== Core Attribute Identity ==========
 
    Uuid uuid_{};
 
    uint16_t handle_ = 0;
 
    uint16_t properties_ = 0;
 
    // ========== Static Attribute Value Storage ==========
 
    const uint8_t* static_value_ptr_ = nullptr;
 
    size_t static_value_size_ = 0;
 
    // ========== Dynamic Attribute Value Storage ==========
 
    std::vector<uint8_t> dynamic_value_{};
 
    // ========== Callback Functions ==========
 
    ReadCallback read_callback_{};
 
    WriteCallback write_callback_{};
};
 
std::ostream& operator<<(std::ostream& os, const Attribute& attr);
 
// Bitwise operators for Attribute::Properties enum
// These operators enable convenient property flag manipulation:
//   uint16_t props = Attribute::Properties::kRead | Attribute::Properties::kWrite;
 
constexpr uint16_t operator|(Attribute::Properties lhs, Attribute::Properties rhs) {
    return static_cast<uint16_t>(lhs) | static_cast<uint16_t>(rhs);
}
 
constexpr uint16_t operator&(Attribute::Properties lhs, Attribute::Properties rhs) {
    return static_cast<uint16_t>(lhs) & static_cast<uint16_t>(rhs);
}
 
constexpr uint16_t operator^(Attribute::Properties lhs, Attribute::Properties rhs) {
    return static_cast<uint16_t>(lhs) ^ static_cast<uint16_t>(rhs);
}
 
constexpr uint16_t operator~(Attribute::Properties value) {
    return static_cast<uint16_t>(~static_cast<uint16_t>(value));
}
 
constexpr uint16_t operator|=(uint16_t& lhs, Attribute::Properties rhs) {
    lhs = static_cast<uint16_t>(lhs | static_cast<uint16_t>(rhs));
    return lhs;
}
 
constexpr uint16_t operator&=(uint16_t& lhs, Attribute::Properties rhs) {
    lhs = static_cast<uint16_t>(lhs & static_cast<uint16_t>(rhs));
    return lhs;
}
 
constexpr uint16_t operator^=(uint16_t& lhs, Attribute::Properties rhs) {
    lhs = static_cast<uint16_t>(lhs ^ static_cast<uint16_t>(rhs));
    return lhs;
}
 
constexpr uint16_t operator|(uint16_t lhs, Attribute::Properties rhs) {
    return lhs | static_cast<uint16_t>(rhs);
}
 
constexpr uint16_t operator&(uint16_t lhs, Attribute::Properties rhs) {
    return lhs & static_cast<uint16_t>(rhs);
}
 
constexpr uint16_t operator^(uint16_t lhs, Attribute::Properties rhs) {
    return lhs ^ static_cast<uint16_t>(rhs);
}
 
constexpr uint16_t operator|(Attribute::Properties lhs, uint16_t rhs) {
    return static_cast<uint16_t>(lhs) | rhs;
}
 
constexpr uint16_t operator&(Attribute::Properties lhs, uint16_t rhs) {
    return static_cast<uint16_t>(lhs) & rhs;
}
 
constexpr uint16_t operator^(Attribute::Properties lhs, uint16_t rhs) {
    return static_cast<uint16_t>(lhs) ^ rhs;
}
 
}  // namespace c7222
 
#endif  // ELEC_C7222_BLE_GATT_ATTRIBUTE_H_