service.hpp

Go to the documentation of this file.

#ifndef ELEC_C7222_BLE_GATT_SERVICE_HPP_
#define ELEC_C7222_BLE_GATT_SERVICE_HPP_
 
#include "characteristic.hpp"
#include "uuid.hpp"
 
#include <iosfwd>
#include <list>
#include <vector>
 
namespace c7222 {
 
class Service : public MovableOnly {
   public:
 
    enum class ServiceType : uint8_t {
        kPrimary = 0,
        kSecondary = 1
    };
 
 
    explicit Service(const Uuid& uuid, ServiceType service_type = ServiceType::kPrimary,
        uint16_t declaration_handle = 0);
 
    explicit Service(Attribute&& declaration_attr,
                     std::vector<Attribute>&& included_service_declarations,
                     std::list<Characteristic>&& characteristics);
 
    Service(Service&& other) noexcept = default;
 
    Service& operator=(Service&& other) noexcept = default;
 
    Service() = delete;
    ~Service() override = default;
 
    static std::list<Service> ParseFromAttributes(std::list<Attribute>& attributes);
 
 
    [[nodiscard]] const Uuid& GetUuid() const { return uuid_; }
 
    [[nodiscard]] ServiceType GetServiceType() const { return service_type_; }
 
    [[nodiscard]] uint16_t GetDeclarationHandle() const { return declaration_attr_.GetHandle(); }
 
    [[nodiscard]] size_t GetCharacteristicCount() const { return characteristics_.size(); }
 
    [[nodiscard]] const std::list<Characteristic>& GetCharacteristics() const {
        return characteristics_;
    }
    std::list<Characteristic>& GetCharacteristics() {
        return characteristics_;
    }
 
    Characteristic& GetCharacteristic(size_t index);
 
    [[nodiscard]] const Characteristic& GetCharacteristic(size_t index) const;
 
    Characteristic* FindCharacteristicByUuid(const Uuid& uuid);
 
    [[nodiscard]] std::list<Characteristic*> FindCharacteristicsByProperties(Characteristic::Properties properties) const;
 
    [[nodiscard]] std::list<Characteristic*> FindCharacteristicsDynamic() const;
 
 
 
    [[nodiscard]] bool HasCharacteristicsRequiringAuthentication() const;
 
    [[nodiscard]] bool HasCharacteristicsRequiringEncryption() const;
 
    [[nodiscard]] bool HasCharacteristicsRequiringAuthorization() const;
 
 
    [[nodiscard]] std::list<Characteristic*> FindCharacteristicsWritable() const {
        return FindCharacteristicsByProperties(Characteristic::Properties::kWrite);
    }
 
    [[nodiscard]] std::list<Characteristic*> FindCharacteristicsReadable() const {
        return FindCharacteristicsByProperties(Characteristic::Properties::kRead);
    }
 
    [[nodiscard]] std::list<Characteristic*> FindCharacteristicsNotifiableOrIndicatable() const {
        return FindCharacteristicsByProperties(Characteristic::Properties::kNotify | Characteristic::Properties::kIndicate);
    }
 
    [[nodiscard]] const Characteristic* FindCharacteristicByUuid(const Uuid& uuid) const;
 
    Characteristic* FindCharacteristicByHandle(uint16_t handle);
 
    [[nodiscard]] const Characteristic* FindCharacteristicByHandle(uint16_t handle) const;
 
    Attribute* FindServiceAttributeByHandle(uint16_t handle);
 
    [[nodiscard]] const Attribute* FindServiceAttributeByHandle(uint16_t handle) const;
 
 
    [[nodiscard]] size_t GetIncludedServiceCount() const { return included_services_.size(); }
 
    Service& GetIncludedService(size_t index);
 
    [[nodiscard]] const Service& GetIncludedService(size_t index) const;
 
    [[nodiscard]] size_t GetIncludedServiceDeclarationCount() const { return included_service_declarations_.size(); }
 
    [[nodiscard]] bool IsValid() const;
 
    [[nodiscard]] bool Uses128BitUuid() const { return uuid_.Is128Bit(); }
 
    void SetConnectionHandle(uint16_t connection_handle);
 
    [[nodiscard]] uint16_t GetConnectionHandle() const { return connection_handle_; }
 
 
    Characteristic& AddCharacteristic(Characteristic&& characteristic);
 
    Characteristic& CreateCharacteristic(const Uuid& uuid,
                                         uint8_t properties,
                                         uint16_t declaration_handle,
                                         uint16_t value_handle);
 
    bool RemoveCharacteristic(size_t index);
 
    void ClearCharacteristics();
 
 
    void AddIncludedService(const Service& included_service, uint16_t declaration_handle = 0);
 
    bool RemoveIncludedService(size_t index);
 
    void ClearIncludedServices();
 
 
    auto begin() { return characteristics_.begin(); }
 
    auto end() { return characteristics_.end(); }
 
    [[nodiscard]] auto begin() const { return characteristics_.begin(); }
 
    [[nodiscard]] auto end() const { return characteristics_.end(); }
 
    [[nodiscard]] auto cbegin() const { return characteristics_.cbegin(); }
 
    [[nodiscard]] auto cend() const { return characteristics_.cend(); }
 
 
    friend std::ostream& operator<<(std::ostream& os, const Service& service);
 
private:
    Uuid uuid_;
 
    ServiceType service_type_;
 
    Attribute declaration_attr_;
 
    uint16_t connection_handle_ = 0;
 
    std::list<Characteristic> characteristics_;
 
    std::list<Service> included_services_;
 
    std::vector<Attribute> included_service_declarations_;
 
};
 
}  // namespace c7222
 
#endif  // ELEC_C7222_BLE_GATT_SERVICE_HPP_