ble.hpp

Go to the documentation of this file.

/* SPDX-License-Identifier: Apache-2.0 */
/* Copyright 2017-2019 Peter A. Bigot */
 
#ifndef PABIGOT_BLE_HPP
#define PABIGOT_BLE_HPP
#pragma once
 
#include <algorithm>
#include <array>
#include <chrono>
#include <cstring>
#include <stdexcept>
#include <string>
 
#include <pabigot/byteorder.hpp>
 
namespace pabigot {
 
namespace ble {
 
namespace details {
 
template <unsigned int clock_bit>
using clk_type = std::chrono::duration<uint32_t, std::ratio<(1U << clock_bit), 3200>>;
 
template <std::size_t nb>
class uuid_type : public std::array<uint8_t, nb>
{
public:
  using super_type = std::array<uint8_t, nb>;
 
  static constexpr std::size_t byte_length = nb;
 
  static constexpr std::size_t bit_length = 8 * byte_length;
 
  // We don't inherit the base class constructors because gcc through 7.3
  // doesn't handle them correctly.  Something about the default constructor
  // not working.
  //
  // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83921
 
  constexpr uuid_type () :
    super_type{}
  { }
 
  constexpr uuid_type (const super_type& arr) :
    super_type{arr}
  { }
 
  constexpr uuid_type (super_type& arr) :
    super_type{arr}
  { }
 
  constexpr uuid_type (const uint8_t (&arr)[byte_length]) :
    super_type{}
  {
    std::copy(arr, byte_length + arr, this->begin());
  }
 
  constexpr uuid_type (uint8_t (&arr)[byte_length]) :
    super_type{}
  {
    std::copy(arr, byte_length + arr, this->begin());
  }
};
 
template <typename Int>
constexpr Int
to_integer (const uuid_type<sizeof(Int)>& uuid) noexcept
{
  using integer_type = Int;
  union { // @todo c++20 use std::byte
    integer_type integer;
    uint8_t u8;
  } u{};
  std::copy(uuid.begin(), uuid.end(), &u.u8);
  return byteorder::host_x_le(u.integer);
}
} // namespace details
 
using clk1_type = details::clk_type<1>;
 
using clk2_type = details::clk_type<2>;
 
using clk5_type = details::clk_type<5>;
 
class uuid16_type : public details::uuid_type<2>
{
  using super_type = details::uuid_type<2>;
 
public:
  using integer_type = uint16_t;
 
  // Expose base class constructors
  using super_type::super_type;
 
  explicit constexpr uuid16_type (integer_type src) :
    super_type{}
  {
    union { // @todo c++20 use std::byte
      integer_type integer;
      uint8_t u8;
    } u{byteorder::host_x_le(src)};
    std::copy(&u.u8, super_type::byte_length + &u.u8, begin());
  }
 
  integer_type as_integer () const noexcept;
 
  std::string as_string () const noexcept;
};
 
class uuid32_type : public details::uuid_type<4>
{
  using super_type = details::uuid_type<4>;
 
public:
  using integer_type = uint32_t;
 
  // Expose base class constructors
  using super_type::super_type;
 
  explicit constexpr uuid32_type (integer_type src) :
    super_type{}
  {
    union { // @todo c++20 use std::byte
      integer_type integer;
      uint8_t u8;
    } u{byteorder::host_x_le(src)};
    std::copy(&u.u8, super_type::byte_length + &u.u8, begin());
  }
 
  integer_type as_integer () const noexcept
  {
    return details::to_integer<integer_type>(*this);
  }
 
  std::string as_string () const noexcept;
};
 
class uuid128_type : public details::uuid_type<16>
{
  using super_type = details::uuid_type<16>;
 
public:
  static const uuid128_type BLUETOOTH_BASE;
 
  // Expose base class constructors
  using super_type::super_type;
 
  std::string as_string () const noexcept;
 
  bool base_match (const uuid128_type& other) const noexcept;
 
  uuid128_type from_uuid16 (const uuid16_type& uuid16) const noexcept;
 
  uuid128_type from_uuid16 (uint16_t uuid16) const noexcept
  {
    return from_uuid16(uuid16_type{uuid16});
  }
 
  uuid16_type::integer_type uuid16 () const noexcept;
 
  uuid128_type swap_endian () const noexcept;
};
 
} // namespace ble
} // namespace pabigot
 
#if (PABIGOT_OPTION_FULLCPP - 0)
#include <pabigot/ble/fullcpp.hpp>
#endif /* PABIGOT_OPTION_FULLCPP */
 
#endif /* PABIGOT_BLE_HPP */