advertisement_data.hpp

Go to the documentation of this file.

 
#ifndef ELEC_C7222_BLE_GAP_ADVERTISEMENT_DATA_H_
#define ELEC_C7222_BLE_GAP_ADVERTISEMENT_DATA_H_
 
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <iosfwd>
#include <list>
#include <type_traits>
#include <vector>
 
namespace c7222 {
 
constexpr size_t kAdvertisementDataLegacyMaxSize = 31;
constexpr size_t kAdvertisementDataStructHeaderOverhead = 2;
enum class AdvertisementDataType : uint8_t {
    kFlags = 0x01,
    kIncompleteList16BitUuid = 0x02,
    kCompleteList16BitUuid = 0x03,
    kShortenedLocalName = 0x08,
    kCompleteLocalName = 0x09,
    kTxPowerLevel = 0x0A,
    kSlaveConnectionIntervalRange = 0x12,
    kServiceData16BitUuid = 0x16,
    kManufacturerSpecific = 0xFF
};
 
class AdvertisementData {
   public:
    enum class Flags : uint8_t {
        kLeLimitedDiscoverableMode = 0x01,
        kLeGeneralDiscoverableMode = 0x02,
        kBrEdrNotSupported = 0x04,
        kSimultaneousLeAndBrEdrController = 0x08,
        kSimultaneousLeAndBrEdrHost = 0x10,
        kAll = 0x1f,
    };
 
    AdvertisementData(AdvertisementDataType type, const std::vector<uint8_t>& data) {
        Build(type, data.data(), data.size());
    }
 
    template <typename T>
    AdvertisementData(AdvertisementDataType type, const T* object_ptr) {
        static_assert(!std::is_pointer<T>::value, "object_ptr must point to a concrete type");
        // static_assert(!std::is_array<T>::value, "object_ptr must not be an array type");
        Build(type, reinterpret_cast<const std::uint8_t*>(object_ptr), sizeof(T));
    }
 
    template <typename T>
    AdvertisementData(AdvertisementDataType type, const T* object_ptr, size_t elem_count) {
        static_assert(!std::is_pointer<T>::value, "object_ptr must point to a concrete type");
        // static_assert(std::is_array<T>::value, "object_ptr must be an array type");
        Build(type, reinterpret_cast<const std::uint8_t*>(object_ptr), sizeof(T) * elem_count);
    }
 
    template <typename T>
    AdvertisementData(AdvertisementDataType type, const T& object_ref) {
        static_assert(!std::is_pointer<T>::value,
                      "object_ref must refer to a concrete type, not a pointer type");
        if(std::is_object<T>::value)
            Build(type, reinterpret_cast<const std::uint8_t*>(&object_ref), sizeof(T));
        else {
            T obj = object_ref;
            Build(type, reinterpret_cast<const std::uint8_t*>(&obj), sizeof(T));
        }
    }
 
    const std::vector<uint8_t>& GetData() const {
        return data_;
    }
 
    const uint8_t* GetBytes() const {
        return data_.data();
    }
 
    size_t GetSize() const {
        return data_.size();
    }
 
    AdvertisementDataType GetType() const {
        assert(data_.size() >= 2 && "AdvertisementData: data size too small to contain type");
        return static_cast<AdvertisementDataType>(data_[1]);
    }
 
    uint8_t GetLength() const {
        assert(data_.size() >= 1 && "AdvertisementData: data size too small to contain length");
        return data_[0];
    }
 
    std::vector<uint8_t> operator+=(const AdvertisementData& other) const;
 
    bool operator==(const AdvertisementData& other) const {
        return data_ == other.data_;
    }
 
    friend std::ostream& operator<<(std::ostream& os, const AdvertisementData& ad);
    friend std::ostream& operator<<(std::ostream& os, const AdvertisementData::Flags& flag);
 
   private:
    std::vector<uint8_t>::iterator begin() {
        return data_.begin();
    }
    std::vector<uint8_t>::const_iterator begin() const {
        return data_.begin();
    }
    std::vector<uint8_t>::const_iterator cbegin() const {
        return data_.cbegin();
    }
    std::vector<uint8_t>::iterator end() {
        return data_.end();
    }
    std::vector<uint8_t>::const_iterator end() const {
        return data_.end();
    }
    std::vector<uint8_t>::const_iterator cend() const {
        return data_.cend();
    }
 
   public:
    static bool ValidateLength(AdvertisementDataType type, size_t length);
 
    static bool ValidateBuffer(const uint8_t* adv_data, size_t adv_data_size);
 
    static bool ValidateBuffer(const std::vector<uint8_t>& adv_data) {
        return ValidateBuffer(adv_data.data(), adv_data.size());
    }
 
   private:
    void Build(AdvertisementDataType type, const uint8_t* data, size_t size);
 
    std::vector<uint8_t> data_;
};
 
std::vector<uint8_t> operator+(const AdvertisementData& lhs, const AdvertisementData& rhs);
 
class AdvertisementDataBuilder {
   public:
    AdvertisementDataBuilder();
 
    explicit AdvertisementDataBuilder(const std::list<AdvertisementData>& ads);
 
    bool Set(const std::list<AdvertisementData>& ads);
 
    bool Set(const uint8_t* data, size_t size);
 
    bool Pop();
 
    bool Push(const AdvertisementData& ad);
 
    void ReplaceOrAdd(const AdvertisementData& ad);
 
    void ReplaceOrAdd(AdvertisementData&& ad);
 
    bool Add(const std::list<AdvertisementData>& ads);
    bool Add(const AdvertisementData& ad);
    const std::vector<uint8_t>& data() const;
 
    const uint8_t* bytes() const;
 
    size_t size() const;
 
    void Clear();
 
    AdvertisementDataBuilder& operator+=(const AdvertisementData& ad);
 
    AdvertisementDataBuilder operator+(const AdvertisementData& ad);
 
    AdvertisementDataBuilder& operator+=(const AdvertisementDataBuilder& adb);
 
    AdvertisementDataBuilder operator+(const AdvertisementDataBuilder& adb);
 
    bool operator==(const AdvertisementDataBuilder& other) const;
    bool Validate() const;
 
    bool Build();
    const std::list<AdvertisementData>& advertisement_data_list() const {
        return advertisements_;
    }
 
    static std::list<AdvertisementData> DecodeBufferToAdvertisementDataList(const uint8_t* adv_data,
                                                                            size_t adv_data_size);
 
    friend std::ostream& operator<<(std::ostream& os, const AdvertisementDataBuilder& adb);
 
   private:
    std::list<AdvertisementData> advertisements_;
    std::vector<uint8_t> data_;
    bool built_ = false;
};
 
}  // namespace c7222
 
constexpr uint8_t operator|(c7222::AdvertisementData::Flags lhs,
                            c7222::AdvertisementData::Flags rhs) {
    return static_cast<uint8_t>(lhs) | static_cast<uint8_t>(rhs);
}
constexpr uint8_t operator|(uint8_t lhs, c7222::AdvertisementData::Flags rhs) {
    uint8_t ret = lhs | static_cast<uint8_t>(rhs);
    assert(ret <= static_cast<uint8_t>(c7222::AdvertisementData::Flags::kAll));
    return ret;
}
constexpr uint8_t operator|=(uint8_t lhs, c7222::AdvertisementData::Flags rhs) {
    uint8_t ret = lhs | static_cast<uint8_t>(rhs);
    assert(ret <= static_cast<uint8_t>(c7222::AdvertisementData::Flags::kAll));
    return ret;
}
constexpr uint8_t operator|(c7222::AdvertisementData::Flags lhs, uint8_t rhs) {
    uint8_t ret = static_cast<uint8_t>(lhs) | rhs;
    assert(ret <= static_cast<uint8_t>(c7222::AdvertisementData::Flags::kAll));
    return ret;
}
 
constexpr uint8_t operator&(c7222::AdvertisementData::Flags lhs,
                            c7222::AdvertisementData::Flags rhs) {
    return static_cast<uint8_t>(lhs) & static_cast<uint8_t>(rhs);
}
 
constexpr uint8_t operator&(uint8_t lhs, c7222::AdvertisementData::Flags rhs) {
    uint8_t ret = lhs & static_cast<uint8_t>(rhs);
    assert(ret <= static_cast<uint8_t>(c7222::AdvertisementData::Flags::kAll));
    return ret;
}
 
constexpr uint8_t operator&=(uint8_t lhs, c7222::AdvertisementData::Flags rhs) {
    uint8_t ret = lhs & static_cast<uint8_t>(rhs);
    assert(ret <= static_cast<uint8_t>(c7222::AdvertisementData::Flags::kAll));
    return ret;
}
 
constexpr uint8_t operator&(c7222::AdvertisementData::Flags lhs, uint8_t rhs) {
    uint8_t ret = static_cast<uint8_t>(lhs) & rhs;
    assert(ret <= static_cast<uint8_t>(c7222::AdvertisementData::Flags::kAll));
    return ret;
}
 
constexpr uint8_t operator^(uint8_t lhs, c7222::AdvertisementData::Flags rhs) {
    uint8_t ret = lhs ^ static_cast<uint8_t>(rhs);
    assert(ret <= static_cast<uint8_t>(c7222::AdvertisementData::Flags::kAll));
    return ret;
}
constexpr uint8_t operator^=(uint8_t lhs, c7222::AdvertisementData::Flags rhs) {
    uint8_t ret = lhs ^ static_cast<uint8_t>(rhs);
    assert(ret <= static_cast<uint8_t>(c7222::AdvertisementData::Flags::kAll));
    return ret;
}
constexpr uint8_t operator^(c7222::AdvertisementData::Flags lhs, uint8_t rhs) {
    uint8_t ret = static_cast<uint8_t>(lhs) & rhs;
    assert(ret <= static_cast<uint8_t>(c7222::AdvertisementData::Flags::kAll));
    return ret;
}
 
#endif  // ELEC_C7222_BLE_GAP_ADVERTISEMENT_DATA_H_