xref: /aosp_15_r20/out/soong/.intermediates/packages/modules/Bluetooth/system/rust/libbluetooth_core_rs_bridge_codegen/gen/gensrcs/packages/modules/Bluetooth/system/rust/src/gatt/ffi.cc

#include "types/bluetooth/uuid.h"
#include "src/gatt/ffi/gatt_shim.h"
#include "stack/arbiter/acl_arbiter.h"
#include <algorithm>
#include <array>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <initializer_list>
#include <iterator>
#include <memory>
#include <new>
#include <stdexcept>
#include <type_traits>
#include <utility>

namespace rust {
inline namespace cxxbridge1 {
// #include "rust/cxx.h"

#ifndef CXXBRIDGE1_PANIC
#define CXXBRIDGE1_PANIC
template <typename Exception>
void panic [[noreturn]] (const char *msg);
#endif // CXXBRIDGE1_PANIC

namespace {
template <typename T>
class impl;
} // namespace

class Opaque;

template <typename T>
::std::size_t size_of();
template <typename T>
::std::size_t align_of();

#ifndef CXXBRIDGE1_RUST_SLICE
#define CXXBRIDGE1_RUST_SLICE
namespace detail {
template <bool>
struct copy_assignable_if {};

template <>
struct copy_assignable_if<false> {
  copy_assignable_if() noexcept = default;
  copy_assignable_if(const copy_assignable_if &) noexcept = default;
  copy_assignable_if &operator=(const copy_assignable_if &) &noexcept = delete;
  copy_assignable_if &operator=(copy_assignable_if &&) &noexcept = default;
};
} // namespace detail

template <typename T>
class Slice final
    : private detail::copy_assignable_if<std::is_const<T>::value> {
public:
  using value_type = T;

  Slice() noexcept;
  Slice(T *, std::size_t count) noexcept;

  Slice &operator=(const Slice<T> &) &noexcept = default;
  Slice &operator=(Slice<T> &&) &noexcept = default;

  T *data() const noexcept;
  std::size_t size() const noexcept;
  std::size_t length() const noexcept;
  bool empty() const noexcept;

  T &operator[](std::size_t n) const noexcept;
  T &at(std::size_t n) const;
  T &front() const noexcept;
  T &back() const noexcept;

  Slice(const Slice<T> &) noexcept = default;
  ~Slice() noexcept = default;

  class iterator;
  iterator begin() const noexcept;
  iterator end() const noexcept;

  void swap(Slice &) noexcept;

private:
  class uninit;
  Slice(uninit) noexcept;
  friend impl<Slice>;
  friend void sliceInit(void *, const void *, std::size_t) noexcept;
  friend void *slicePtr(const void *) noexcept;
  friend std::size_t sliceLen(const void *) noexcept;

  std::array<std::uintptr_t, 2> repr;
};

template <typename T>
class Slice<T>::iterator final {
public:
  using iterator_category = std::random_access_iterator_tag;
  using value_type = T;
  using difference_type = std::ptrdiff_t;
  using pointer = typename std::add_pointer<T>::type;
  using reference = typename std::add_lvalue_reference<T>::type;

  reference operator*() const noexcept;
  pointer operator->() const noexcept;
  reference operator[](difference_type) const noexcept;

  iterator &operator++() noexcept;
  iterator operator++(int) noexcept;
  iterator &operator--() noexcept;
  iterator operator--(int) noexcept;

  iterator &operator+=(difference_type) noexcept;
  iterator &operator-=(difference_type) noexcept;
  iterator operator+(difference_type) const noexcept;
  iterator operator-(difference_type) const noexcept;
  difference_type operator-(const iterator &) const noexcept;

  bool operator==(const iterator &) const noexcept;
  bool operator!=(const iterator &) const noexcept;
  bool operator<(const iterator &) const noexcept;
  bool operator<=(const iterator &) const noexcept;
  bool operator>(const iterator &) const noexcept;
  bool operator>=(const iterator &) const noexcept;

private:
  friend class Slice;
  void *pos;
  std::size_t stride;
};

template <typename T>
Slice<T>::Slice() noexcept {
  sliceInit(this, reinterpret_cast<void *>(align_of<T>()), 0);
}

template <typename T>
Slice<T>::Slice(T *s, std::size_t count) noexcept {
  assert(s != nullptr || count == 0);
  sliceInit(this,
            s == nullptr && count == 0
                ? reinterpret_cast<void *>(align_of<T>())
                : const_cast<typename std::remove_const<T>::type *>(s),
            count);
}

template <typename T>
T *Slice<T>::data() const noexcept {
  return reinterpret_cast<T *>(slicePtr(this));
}

template <typename T>
std::size_t Slice<T>::size() const noexcept {
  return sliceLen(this);
}

template <typename T>
std::size_t Slice<T>::length() const noexcept {
  return this->size();
}

template <typename T>
bool Slice<T>::empty() const noexcept {
  return this->size() == 0;
}

template <typename T>
T &Slice<T>::operator[](std::size_t n) const noexcept {
  assert(n < this->size());
  auto ptr = static_cast<char *>(slicePtr(this)) + size_of<T>() * n;
  return *reinterpret_cast<T *>(ptr);
}

template <typename T>
T &Slice<T>::at(std::size_t n) const {
  if (n >= this->size()) {
    panic<std::out_of_range>("rust::Slice index out of range");
  }
  return (*this)[n];
}

template <typename T>
T &Slice<T>::front() const noexcept {
  assert(!this->empty());
  return (*this)[0];
}

template <typename T>
T &Slice<T>::back() const noexcept {
  assert(!this->empty());
  return (*this)[this->size() - 1];
}

template <typename T>
typename Slice<T>::iterator::reference
Slice<T>::iterator::operator*() const noexcept {
  return *static_cast<T *>(this->pos);
}

template <typename T>
typename Slice<T>::iterator::pointer
Slice<T>::iterator::operator->() const noexcept {
  return static_cast<T *>(this->pos);
}

template <typename T>
typename Slice<T>::iterator::reference Slice<T>::iterator::operator[](
    typename Slice<T>::iterator::difference_type n) const noexcept {
  auto ptr = static_cast<char *>(this->pos) + this->stride * n;
  return *reinterpret_cast<T *>(ptr);
}

template <typename T>
typename Slice<T>::iterator &Slice<T>::iterator::operator++() noexcept {
  this->pos = static_cast<char *>(this->pos) + this->stride;
  return *this;
}

template <typename T>
typename Slice<T>::iterator Slice<T>::iterator::operator++(int) noexcept {
  auto ret = iterator(*this);
  this->pos = static_cast<char *>(this->pos) + this->stride;
  return ret;
}

template <typename T>
typename Slice<T>::iterator &Slice<T>::iterator::operator--() noexcept {
  this->pos = static_cast<char *>(this->pos) - this->stride;
  return *this;
}

template <typename T>
typename Slice<T>::iterator Slice<T>::iterator::operator--(int) noexcept {
  auto ret = iterator(*this);
  this->pos = static_cast<char *>(this->pos) - this->stride;
  return ret;
}

template <typename T>
typename Slice<T>::iterator &Slice<T>::iterator::operator+=(
    typename Slice<T>::iterator::difference_type n) noexcept {
  this->pos = static_cast<char *>(this->pos) + this->stride * n;
  return *this;
}

template <typename T>
typename Slice<T>::iterator &Slice<T>::iterator::operator-=(
    typename Slice<T>::iterator::difference_type n) noexcept {
  this->pos = static_cast<char *>(this->pos) - this->stride * n;
  return *this;
}

template <typename T>
typename Slice<T>::iterator Slice<T>::iterator::operator+(
    typename Slice<T>::iterator::difference_type n) const noexcept {
  auto ret = iterator(*this);
  ret.pos = static_cast<char *>(this->pos) + this->stride * n;
  return ret;
}

template <typename T>
typename Slice<T>::iterator Slice<T>::iterator::operator-(
    typename Slice<T>::iterator::difference_type n) const noexcept {
  auto ret = iterator(*this);
  ret.pos = static_cast<char *>(this->pos) - this->stride * n;
  return ret;
}

template <typename T>
typename Slice<T>::iterator::difference_type
Slice<T>::iterator::operator-(const iterator &other) const noexcept {
  auto diff = std::distance(static_cast<char *>(other.pos),
                            static_cast<char *>(this->pos));
  return diff / static_cast<typename Slice<T>::iterator::difference_type>(
                    this->stride);
}

template <typename T>
bool Slice<T>::iterator::operator==(const iterator &other) const noexcept {
  return this->pos == other.pos;
}

template <typename T>
bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept {
  return this->pos != other.pos;
}

template <typename T>
bool Slice<T>::iterator::operator<(const iterator &other) const noexcept {
  return this->pos < other.pos;
}

template <typename T>
bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept {
  return this->pos <= other.pos;
}

template <typename T>
bool Slice<T>::iterator::operator>(const iterator &other) const noexcept {
  return this->pos > other.pos;
}

template <typename T>
bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept {
  return this->pos >= other.pos;
}

template <typename T>
typename Slice<T>::iterator Slice<T>::begin() const noexcept {
  iterator it;
  it.pos = slicePtr(this);
  it.stride = size_of<T>();
  return it;
}

template <typename T>
typename Slice<T>::iterator Slice<T>::end() const noexcept {
  iterator it = this->begin();
  it.pos = static_cast<char *>(it.pos) + it.stride * this->size();
  return it;
}

template <typename T>
void Slice<T>::swap(Slice &rhs) noexcept {
  std::swap(*this, rhs);
}
#endif // CXXBRIDGE1_RUST_SLICE

#ifndef CXXBRIDGE1_RUST_BITCOPY_T
#define CXXBRIDGE1_RUST_BITCOPY_T
struct unsafe_bitcopy_t final {
  explicit unsafe_bitcopy_t() = default;
};
#endif // CXXBRIDGE1_RUST_BITCOPY_T

#ifndef CXXBRIDGE1_RUST_BITCOPY
#define CXXBRIDGE1_RUST_BITCOPY
constexpr unsafe_bitcopy_t unsafe_bitcopy{};
#endif // CXXBRIDGE1_RUST_BITCOPY

#ifndef CXXBRIDGE1_RUST_VEC
#define CXXBRIDGE1_RUST_VEC
template <typename T>
class Vec final {
public:
  using value_type = T;

  Vec() noexcept;
  Vec(std::initializer_list<T>);
  Vec(const Vec &);
  Vec(Vec &&) noexcept;
  ~Vec() noexcept;

  Vec &operator=(Vec &&) &noexcept;
  Vec &operator=(const Vec &) &;

  std::size_t size() const noexcept;
  bool empty() const noexcept;
  const T *data() const noexcept;
  T *data() noexcept;
  std::size_t capacity() const noexcept;

  const T &operator[](std::size_t n) const noexcept;
  const T &at(std::size_t n) const;
  const T &front() const noexcept;
  const T &back() const noexcept;

  T &operator[](std::size_t n) noexcept;
  T &at(std::size_t n);
  T &front() noexcept;
  T &back() noexcept;

  void reserve(std::size_t new_cap);
  void push_back(const T &value);
  void push_back(T &&value);
  template <typename... Args>
  void emplace_back(Args &&...args);
  void truncate(std::size_t len);
  void clear();

  using iterator = typename Slice<T>::iterator;
  iterator begin() noexcept;
  iterator end() noexcept;

  using const_iterator = typename Slice<const T>::iterator;
  const_iterator begin() const noexcept;
  const_iterator end() const noexcept;
  const_iterator cbegin() const noexcept;
  const_iterator cend() const noexcept;

  void swap(Vec &) noexcept;

  Vec(unsafe_bitcopy_t, const Vec &) noexcept;

private:
  void reserve_total(std::size_t new_cap) noexcept;
  void set_len(std::size_t len) noexcept;
  void drop() noexcept;

  friend void swap(Vec &lhs, Vec &rhs) noexcept { lhs.swap(rhs); }

  std::array<std::uintptr_t, 3> repr;
};

template <typename T>
Vec<T>::Vec(std::initializer_list<T> init) : Vec{} {
  this->reserve_total(init.size());
  std::move(init.begin(), init.end(), std::back_inserter(*this));
}

template <typename T>
Vec<T>::Vec(const Vec &other) : Vec() {
  this->reserve_total(other.size());
  std::copy(other.begin(), other.end(), std::back_inserter(*this));
}

template <typename T>
Vec<T>::Vec(Vec &&other) noexcept : repr(other.repr) {
  new (&other) Vec();
}

template <typename T>
Vec<T>::~Vec() noexcept {
  this->drop();
}

template <typename T>
Vec<T> &Vec<T>::operator=(Vec &&other) &noexcept {
  this->drop();
  this->repr = other.repr;
  new (&other) Vec();
  return *this;
}

template <typename T>
Vec<T> &Vec<T>::operator=(const Vec &other) & {
  if (this != &other) {
    this->drop();
    new (this) Vec(other);
  }
  return *this;
}

template <typename T>
bool Vec<T>::empty() const noexcept {
  return this->size() == 0;
}

template <typename T>
T *Vec<T>::data() noexcept {
  return const_cast<T *>(const_cast<const Vec<T> *>(this)->data());
}

template <typename T>
const T &Vec<T>::operator[](std::size_t n) const noexcept {
  assert(n < this->size());
  auto data = reinterpret_cast<const char *>(this->data());
  return *reinterpret_cast<const T *>(data + n * size_of<T>());
}

template <typename T>
const T &Vec<T>::at(std::size_t n) const {
  if (n >= this->size()) {
    panic<std::out_of_range>("rust::Vec index out of range");
  }
  return (*this)[n];
}

template <typename T>
const T &Vec<T>::front() const noexcept {
  assert(!this->empty());
  return (*this)[0];
}

template <typename T>
const T &Vec<T>::back() const noexcept {
  assert(!this->empty());
  return (*this)[this->size() - 1];
}

template <typename T>
T &Vec<T>::operator[](std::size_t n) noexcept {
  assert(n < this->size());
  auto data = reinterpret_cast<char *>(this->data());
  return *reinterpret_cast<T *>(data + n * size_of<T>());
}

template <typename T>
T &Vec<T>::at(std::size_t n) {
  if (n >= this->size()) {
    panic<std::out_of_range>("rust::Vec index out of range");
  }
  return (*this)[n];
}

template <typename T>
T &Vec<T>::front() noexcept {
  assert(!this->empty());
  return (*this)[0];
}

template <typename T>
T &Vec<T>::back() noexcept {
  assert(!this->empty());
  return (*this)[this->size() - 1];
}

template <typename T>
void Vec<T>::reserve(std::size_t new_cap) {
  this->reserve_total(new_cap);
}

template <typename T>
void Vec<T>::push_back(const T &value) {
  this->emplace_back(value);
}

template <typename T>
void Vec<T>::push_back(T &&value) {
  this->emplace_back(std::move(value));
}

template <typename T>
template <typename... Args>
void Vec<T>::emplace_back(Args &&...args) {
  auto size = this->size();
  this->reserve_total(size + 1);
  ::new (reinterpret_cast<T *>(reinterpret_cast<char *>(this->data()) +
                               size * size_of<T>()))
      T(std::forward<Args>(args)...);
  this->set_len(size + 1);
}

template <typename T>
void Vec<T>::clear() {
  this->truncate(0);
}

template <typename T>
typename Vec<T>::iterator Vec<T>::begin() noexcept {
  return Slice<T>(this->data(), this->size()).begin();
}

template <typename T>
typename Vec<T>::iterator Vec<T>::end() noexcept {
  return Slice<T>(this->data(), this->size()).end();
}

template <typename T>
typename Vec<T>::const_iterator Vec<T>::begin() const noexcept {
  return this->cbegin();
}

template <typename T>
typename Vec<T>::const_iterator Vec<T>::end() const noexcept {
  return this->cend();
}

template <typename T>
typename Vec<T>::const_iterator Vec<T>::cbegin() const noexcept {
  return Slice<const T>(this->data(), this->size()).begin();
}

template <typename T>
typename Vec<T>::const_iterator Vec<T>::cend() const noexcept {
  return Slice<const T>(this->data(), this->size()).end();
}

template <typename T>
void Vec<T>::swap(Vec &rhs) noexcept {
  using std::swap;
  swap(this->repr, rhs.repr);
}

template <typename T>
Vec<T>::Vec(unsafe_bitcopy_t, const Vec &bits) noexcept : repr(bits.repr) {}
#endif // CXXBRIDGE1_RUST_VEC

#ifndef CXXBRIDGE1_RUST_FN
#define CXXBRIDGE1_RUST_FN
template <typename Signature>
class Fn;

template <typename Ret, typename... Args>
class Fn<Ret(Args...)> final {
public:
  Ret operator()(Args... args) const noexcept;
  Fn operator*() const noexcept;

private:
  Ret (*trampoline)(Args..., void *fn) noexcept;
  void *fn;
};

template <typename Ret, typename... Args>
Ret Fn<Ret(Args...)>::operator()(Args... args) const noexcept {
  return (*this->trampoline)(std::forward<Args>(args)..., this->fn);
}

template <typename Ret, typename... Args>
Fn<Ret(Args...)> Fn<Ret(Args...)>::operator*() const noexcept {
  return *this;
}
#endif // CXXBRIDGE1_RUST_FN

#ifndef CXXBRIDGE1_IS_COMPLETE
#define CXXBRIDGE1_IS_COMPLETE
namespace detail {
namespace {
template <typename T, typename = std::size_t>
struct is_complete : std::false_type {};
template <typename T>
struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
} // namespace
} // namespace detail
#endif // CXXBRIDGE1_IS_COMPLETE

#ifndef CXXBRIDGE1_LAYOUT
#define CXXBRIDGE1_LAYOUT
class layout {
  template <typename T>
  friend std::size_t size_of();
  template <typename T>
  friend std::size_t align_of();
  template <typename T>
  static typename std::enable_if<std::is_base_of<Opaque, T>::value,
                                 std::size_t>::type
  do_size_of() {
    return T::layout::size();
  }
  template <typename T>
  static typename std::enable_if<!std::is_base_of<Opaque, T>::value,
                                 std::size_t>::type
  do_size_of() {
    return sizeof(T);
  }
  template <typename T>
  static
      typename std::enable_if<detail::is_complete<T>::value, std::size_t>::type
      size_of() {
    return do_size_of<T>();
  }
  template <typename T>
  static typename std::enable_if<std::is_base_of<Opaque, T>::value,
                                 std::size_t>::type
  do_align_of() {
    return T::layout::align();
  }
  template <typename T>
  static typename std::enable_if<!std::is_base_of<Opaque, T>::value,
                                 std::size_t>::type
  do_align_of() {
    return alignof(T);
  }
  template <typename T>
  static
      typename std::enable_if<detail::is_complete<T>::value, std::size_t>::type
      align_of() {
    return do_align_of<T>();
  }
};

template <typename T>
std::size_t size_of() {
  return layout::size_of<T>();
}

template <typename T>
std::size_t align_of() {
  return layout::align_of<T>();
}
#endif // CXXBRIDGE1_LAYOUT

#ifndef CXXBRIDGE1_RELOCATABLE
#define CXXBRIDGE1_RELOCATABLE
namespace detail {
template <typename... Ts>
struct make_void {
  using type = void;
};

template <typename... Ts>
using void_t = typename make_void<Ts...>::type;

template <typename Void, template <typename...> class, typename...>
struct detect : std::false_type {};
template <template <typename...> class T, typename... A>
struct detect<void_t<T<A...>>, T, A...> : std::true_type {};

template <template <typename...> class T, typename... A>
using is_detected = detect<void, T, A...>;

template <typename T>
using detect_IsRelocatable = typename T::IsRelocatable;

template <typename T>
struct get_IsRelocatable
    : std::is_same<typename T::IsRelocatable, std::true_type> {};
} // namespace detail

template <typename T>
struct IsRelocatable
    : std::conditional<
          detail::is_detected<detail::detect_IsRelocatable, T>::value,
          detail::get_IsRelocatable<T>,
          std::integral_constant<
              bool, std::is_trivially_move_constructible<T>::value &&
                        std::is_trivially_destructible<T>::value>>::type {};
#endif // CXXBRIDGE1_RELOCATABLE

template <typename T>
union ManuallyDrop {
  T value;
  ManuallyDrop(T &&value) : value(::std::move(value)) {}
  ~ManuallyDrop() {}
};

namespace {
template <bool> struct deleter_if {
  template <typename T> void operator()(T *) {}
};

template <> struct deleter_if<true> {
  template <typename T> void operator()(T *ptr) { ptr->~T(); }
};

template <typename T>
struct IsRelocatableOrArray : IsRelocatable<T> {};
template <typename T, ::std::size_t N>
struct IsRelocatableOrArray<T[N]> : IsRelocatableOrArray<T> {};
} // namespace
} // namespace cxxbridge1
} // namespace rust

namespace bluetooth {
  namespace gatt {
    using AttributeBackingType = ::bluetooth::gatt::AttributeBackingType;
    using GattServerCallbacks = ::bluetooth::gatt::GattServerCallbacks;
    enum class GattRecordType : ::std::uint8_t;
    struct GattRecord;
  }
  namespace shim {
    namespace arbiter {
      using InterceptAction = ::bluetooth::shim::arbiter::InterceptAction;
    }
  }
}

namespace bluetooth {
namespace gatt {
static_assert(::std::is_enum<AttributeBackingType>::value, "expected enum");
static_assert(sizeof(AttributeBackingType) == sizeof(::std::uint32_t), "incorrect size");
static_assert(static_cast<::std::uint32_t>(AttributeBackingType::CHARACTERISTIC) == 0, "disagrees with the value in #[cxx::bridge]");
static_assert(static_cast<::std::uint32_t>(AttributeBackingType::DESCRIPTOR) == 1, "disagrees with the value in #[cxx::bridge]");
} // namespace gatt

namespace shim {
namespace arbiter {
static_assert(::std::is_enum<InterceptAction>::value, "expected enum");
static_assert(sizeof(InterceptAction) == sizeof(::std::uint32_t), "incorrect size");
static_assert(static_cast<::std::uint32_t>(InterceptAction::FORWARD) == 0, "disagrees with the value in #[cxx::bridge]");
static_assert(static_cast<::std::uint32_t>(InterceptAction::DROP) == 1, "disagrees with the value in #[cxx::bridge]");
} // namespace arbiter
} // namespace shim

namespace gatt {
#ifndef CXXBRIDGE1_ENUM_bluetooth$gatt$GattRecordType
#define CXXBRIDGE1_ENUM_bluetooth$gatt$GattRecordType
// The type of GATT record supplied over FFI
enum class GattRecordType : ::std::uint8_t {
  PrimaryService = 0,
  SecondaryService = 1,
  IncludedService = 2,
  Characteristic = 3,
  Descriptor = 4,
};
#endif // CXXBRIDGE1_ENUM_bluetooth$gatt$GattRecordType

#ifndef CXXBRIDGE1_STRUCT_bluetooth$gatt$GattRecord
#define CXXBRIDGE1_STRUCT_bluetooth$gatt$GattRecord
// An entry in a service definition received from JNI. See GattRecordType
// for possible types.
struct GattRecord final {
  ::bluetooth::Uuid uuid;
  ::bluetooth::gatt::GattRecordType record_type;
  ::std::uint16_t attribute_handle;
  ::std::uint8_t properties;
  ::std::uint16_t extended_properties;
  ::std::uint16_t permissions;

  using IsRelocatable = ::std::true_type;
};
#endif // CXXBRIDGE1_STRUCT_bluetooth$gatt$GattRecord
} // namespace gatt
} // namespace bluetooth

static_assert(
    ::rust::IsRelocatableOrArray<::bluetooth::Uuid>::value,
    "type bluetooth::Uuid should be trivially move constructible and trivially destructible in C++ to be used as a field of `GattRecord` in Rust");

namespace bluetooth {
namespace gatt {
extern "C" {
void bluetooth$gatt$cxxbridge1$GattServerCallbacks$on_server_read(::bluetooth::gatt::GattServerCallbacks const &self, ::std::uint16_t conn_id, ::std::uint32_t trans_id, ::std::uint16_t attr_handle, ::bluetooth::gatt::AttributeBackingType attr_type, ::std::uint32_t offset, bool is_long) noexcept {
  void (::bluetooth::gatt::GattServerCallbacks::*on_server_read$)(::std::uint16_t, ::std::uint32_t, ::std::uint16_t, ::bluetooth::gatt::AttributeBackingType, ::std::uint32_t, bool) const = &::bluetooth::gatt::GattServerCallbacks::OnServerRead;
  (self.*on_server_read$)(conn_id, trans_id, attr_handle, attr_type, offset, is_long);
}

void bluetooth$gatt$cxxbridge1$GattServerCallbacks$on_server_write(::bluetooth::gatt::GattServerCallbacks const &self, ::std::uint16_t conn_id, ::std::uint32_t trans_id, ::std::uint16_t attr_handle, ::bluetooth::gatt::AttributeBackingType attr_type, ::std::uint32_t offset, bool need_response, bool is_prepare, ::rust::Slice<::std::uint8_t const> value) noexcept {
  void (::bluetooth::gatt::GattServerCallbacks::*on_server_write$)(::std::uint16_t, ::std::uint32_t, ::std::uint16_t, ::bluetooth::gatt::AttributeBackingType, ::std::uint32_t, bool, bool, ::rust::Slice<::std::uint8_t const>) const = &::bluetooth::gatt::GattServerCallbacks::OnServerWrite;
  (self.*on_server_write$)(conn_id, trans_id, attr_handle, attr_type, offset, need_response, is_prepare, value);
}

void bluetooth$gatt$cxxbridge1$GattServerCallbacks$on_execute(::bluetooth::gatt::GattServerCallbacks const &self, ::std::uint16_t conn_id, ::std::uint32_t trans_id, bool execute) noexcept {
  void (::bluetooth::gatt::GattServerCallbacks::*on_execute$)(::std::uint16_t, ::std::uint32_t, bool) const = &::bluetooth::gatt::GattServerCallbacks::OnExecute;
  (self.*on_execute$)(conn_id, trans_id, execute);
}

void bluetooth$gatt$cxxbridge1$GattServerCallbacks$on_indication_sent_confirmation(::bluetooth::gatt::GattServerCallbacks const &self, ::std::uint16_t conn_id, ::std::int32_t status) noexcept {
  void (::bluetooth::gatt::GattServerCallbacks::*on_indication_sent_confirmation$)(::std::uint16_t, ::std::int32_t) const = &::bluetooth::gatt::GattServerCallbacks::OnIndicationSentConfirmation;
  (self.*on_indication_sent_confirmation$)(conn_id, status);
}
} // extern "C"
} // namespace gatt

namespace shim {
namespace arbiter {
extern "C" {
void bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust(::rust::Fn<void(::std::uint8_t, ::std::uint8_t)> on_le_connect, ::rust::Fn<void(::std::uint8_t)> on_le_disconnect, ::rust::Fn<::bluetooth::shim::arbiter::InterceptAction(::std::uint8_t, ::rust::Vec<::std::uint8_t>)> intercept_packet, ::rust::Fn<void(::std::uint8_t)> on_outgoing_mtu_req, ::rust::Fn<void(::std::uint8_t, ::std::size_t)> on_incoming_mtu_resp, ::rust::Fn<void(::std::uint8_t, ::std::size_t)> on_incoming_mtu_req) noexcept {
  void (*StoreCallbacksFromRust$)(::rust::Fn<void(::std::uint8_t, ::std::uint8_t)>, ::rust::Fn<void(::std::uint8_t)>, ::rust::Fn<::bluetooth::shim::arbiter::InterceptAction(::std::uint8_t, ::rust::Vec<::std::uint8_t>)>, ::rust::Fn<void(::std::uint8_t)>, ::rust::Fn<void(::std::uint8_t, ::std::size_t)>, ::rust::Fn<void(::std::uint8_t, ::std::size_t)>) = ::bluetooth::shim::arbiter::StoreCallbacksFromRust;
  StoreCallbacksFromRust$(on_le_connect, on_le_disconnect, intercept_packet, on_outgoing_mtu_req, on_incoming_mtu_resp, on_incoming_mtu_req);
}

void bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust$on_le_connect$1(::std::uint8_t tcb_idx, ::std::uint8_t advertiser, void *) noexcept;

void bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust$on_le_connect$0(::std::uint8_t tcb_idx, ::std::uint8_t advertiser, void *extern$) noexcept {
  bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust$on_le_connect$1(tcb_idx, advertiser, extern$);
}

void bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust$on_le_disconnect$1(::std::uint8_t tcb_idx, void *) noexcept;

void bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust$on_le_disconnect$0(::std::uint8_t tcb_idx, void *extern$) noexcept {
  bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust$on_le_disconnect$1(tcb_idx, extern$);
}

::bluetooth::shim::arbiter::InterceptAction bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust$intercept_packet$1(::std::uint8_t tcb_idx, ::rust::Vec<::std::uint8_t> *packet, void *) noexcept;

::bluetooth::shim::arbiter::InterceptAction bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust$intercept_packet$0(::std::uint8_t tcb_idx, ::rust::Vec<::std::uint8_t> packet, void *extern$) noexcept {
  ::rust::ManuallyDrop<::rust::Vec<::std::uint8_t>> packet$(::std::move(packet));
  return bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust$intercept_packet$1(tcb_idx, &packet$.value, extern$);
}

void bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust$on_outgoing_mtu_req$1(::std::uint8_t tcb_idx, void *) noexcept;

void bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust$on_outgoing_mtu_req$0(::std::uint8_t tcb_idx, void *extern$) noexcept {
  bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust$on_outgoing_mtu_req$1(tcb_idx, extern$);
}

void bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust$on_incoming_mtu_resp$1(::std::uint8_t tcb_idx, ::std::size_t mtu, void *) noexcept;

void bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust$on_incoming_mtu_resp$0(::std::uint8_t tcb_idx, ::std::size_t mtu, void *extern$) noexcept {
  bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust$on_incoming_mtu_resp$1(tcb_idx, mtu, extern$);
}

void bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust$on_incoming_mtu_req$1(::std::uint8_t tcb_idx, ::std::size_t mtu, void *) noexcept;

void bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust$on_incoming_mtu_req$0(::std::uint8_t tcb_idx, ::std::size_t mtu, void *extern$) noexcept {
  bluetooth$shim$arbiter$cxxbridge1$StoreCallbacksFromRust$on_incoming_mtu_req$1(tcb_idx, mtu, extern$);
}

void bluetooth$shim$arbiter$cxxbridge1$SendPacketToPeer(::std::uint8_t tcb_idx, ::rust::Vec<::std::uint8_t> const *packet) noexcept {
  void (*SendPacketToPeer$)(::std::uint8_t, ::rust::Vec<::std::uint8_t>) = ::bluetooth::shim::arbiter::SendPacketToPeer;
  SendPacketToPeer$(tcb_idx, ::rust::Vec<::std::uint8_t>(::rust::unsafe_bitcopy, *packet));
}
} // extern "C"
} // namespace arbiter
} // namespace shim

namespace gatt {
extern "C" {
void bluetooth$gatt$cxxbridge1$open_server(::std::uint8_t server_id) noexcept;

void bluetooth$gatt$cxxbridge1$close_server(::std::uint8_t server_id) noexcept;

void bluetooth$gatt$cxxbridge1$add_service(::std::uint8_t server_id, ::rust::Vec<::bluetooth::gatt::GattRecord> *service_records) noexcept;

void bluetooth$gatt$cxxbridge1$remove_service(::std::uint8_t server_id, ::std::uint16_t service_handle) noexcept;

void bluetooth$gatt$cxxbridge1$send_response(::std::uint8_t server_id, ::std::uint16_t conn_id, ::std::uint32_t trans_id, ::std::uint8_t status, ::rust::Slice<::std::uint8_t const> value) noexcept;

void bluetooth$gatt$cxxbridge1$send_indication(::std::uint8_t _server_id, ::std::uint16_t handle, ::std::uint16_t conn_id, ::rust::Slice<::std::uint8_t const> value) noexcept;

bool bluetooth$gatt$cxxbridge1$is_connection_isolated(::std::uint16_t conn_id) noexcept;

void bluetooth$gatt$cxxbridge1$associate_server_with_advertiser(::std::uint8_t server_id, ::std::uint8_t advertiser_id) noexcept;

void bluetooth$gatt$cxxbridge1$clear_advertiser(::std::uint8_t advertiser_id) noexcept;
} // extern "C"

void open_server(::std::uint8_t server_id) noexcept {
  bluetooth$gatt$cxxbridge1$open_server(server_id);
}

void close_server(::std::uint8_t server_id) noexcept {
  bluetooth$gatt$cxxbridge1$close_server(server_id);
}

void add_service(::std::uint8_t server_id, ::rust::Vec<::bluetooth::gatt::GattRecord> service_records) noexcept {
  ::rust::ManuallyDrop<::rust::Vec<::bluetooth::gatt::GattRecord>> service_records$(::std::move(service_records));
  bluetooth$gatt$cxxbridge1$add_service(server_id, &service_records$.value);
}

void remove_service(::std::uint8_t server_id, ::std::uint16_t service_handle) noexcept {
  bluetooth$gatt$cxxbridge1$remove_service(server_id, service_handle);
}

void send_response(::std::uint8_t server_id, ::std::uint16_t conn_id, ::std::uint32_t trans_id, ::std::uint8_t status, ::rust::Slice<::std::uint8_t const> value) noexcept {
  bluetooth$gatt$cxxbridge1$send_response(server_id, conn_id, trans_id, status, value);
}

void send_indication(::std::uint8_t _server_id, ::std::uint16_t handle, ::std::uint16_t conn_id, ::rust::Slice<::std::uint8_t const> value) noexcept {
  bluetooth$gatt$cxxbridge1$send_indication(_server_id, handle, conn_id, value);
}

bool is_connection_isolated(::std::uint16_t conn_id) noexcept {
  return bluetooth$gatt$cxxbridge1$is_connection_isolated(conn_id);
}

void associate_server_with_advertiser(::std::uint8_t server_id, ::std::uint8_t advertiser_id) noexcept {
  bluetooth$gatt$cxxbridge1$associate_server_with_advertiser(server_id, advertiser_id);
}

void clear_advertiser(::std::uint8_t advertiser_id) noexcept {
  bluetooth$gatt$cxxbridge1$clear_advertiser(advertiser_id);
}
} // namespace gatt
} // namespace bluetooth

extern "C" {
static_assert(::rust::detail::is_complete<::bluetooth::gatt::GattServerCallbacks>::value, "definition of GattServerCallbacks is required");
static_assert(sizeof(::std::unique_ptr<::bluetooth::gatt::GattServerCallbacks>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::bluetooth::gatt::GattServerCallbacks>) == alignof(void *), "");
void cxxbridge1$unique_ptr$bluetooth$gatt$GattServerCallbacks$null(::std::unique_ptr<::bluetooth::gatt::GattServerCallbacks> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::bluetooth::gatt::GattServerCallbacks>();
}
void cxxbridge1$unique_ptr$bluetooth$gatt$GattServerCallbacks$raw(::std::unique_ptr<::bluetooth::gatt::GattServerCallbacks> *ptr, ::bluetooth::gatt::GattServerCallbacks *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::bluetooth::gatt::GattServerCallbacks>(raw);
}
::bluetooth::gatt::GattServerCallbacks const *cxxbridge1$unique_ptr$bluetooth$gatt$GattServerCallbacks$get(::std::unique_ptr<::bluetooth::gatt::GattServerCallbacks> const &ptr) noexcept {
  return ptr.get();
}
::bluetooth::gatt::GattServerCallbacks *cxxbridge1$unique_ptr$bluetooth$gatt$GattServerCallbacks$release(::std::unique_ptr<::bluetooth::gatt::GattServerCallbacks> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$bluetooth$gatt$GattServerCallbacks$drop(::std::unique_ptr<::bluetooth::gatt::GattServerCallbacks> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::bluetooth::gatt::GattServerCallbacks>::value>{}(ptr);
}

void cxxbridge1$rust_vec$bluetooth$gatt$GattRecord$new(::rust::Vec<::bluetooth::gatt::GattRecord> const *ptr) noexcept;
void cxxbridge1$rust_vec$bluetooth$gatt$GattRecord$drop(::rust::Vec<::bluetooth::gatt::GattRecord> *ptr) noexcept;
::std::size_t cxxbridge1$rust_vec$bluetooth$gatt$GattRecord$len(::rust::Vec<::bluetooth::gatt::GattRecord> const *ptr) noexcept;
::std::size_t cxxbridge1$rust_vec$bluetooth$gatt$GattRecord$capacity(::rust::Vec<::bluetooth::gatt::GattRecord> const *ptr) noexcept;
::bluetooth::gatt::GattRecord const *cxxbridge1$rust_vec$bluetooth$gatt$GattRecord$data(::rust::Vec<::bluetooth::gatt::GattRecord> const *ptr) noexcept;
void cxxbridge1$rust_vec$bluetooth$gatt$GattRecord$reserve_total(::rust::Vec<::bluetooth::gatt::GattRecord> *ptr, ::std::size_t new_cap) noexcept;
void cxxbridge1$rust_vec$bluetooth$gatt$GattRecord$set_len(::rust::Vec<::bluetooth::gatt::GattRecord> *ptr, ::std::size_t len) noexcept;
void cxxbridge1$rust_vec$bluetooth$gatt$GattRecord$truncate(::rust::Vec<::bluetooth::gatt::GattRecord> *ptr, ::std::size_t len) noexcept;
} // extern "C"

namespace rust {
inline namespace cxxbridge1 {
template <>
Vec<::bluetooth::gatt::GattRecord>::Vec() noexcept {
  cxxbridge1$rust_vec$bluetooth$gatt$GattRecord$new(this);
}
template <>
void Vec<::bluetooth::gatt::GattRecord>::drop() noexcept {
  return cxxbridge1$rust_vec$bluetooth$gatt$GattRecord$drop(this);
}
template <>
::std::size_t Vec<::bluetooth::gatt::GattRecord>::size() const noexcept {
  return cxxbridge1$rust_vec$bluetooth$gatt$GattRecord$len(this);
}
template <>
::std::size_t Vec<::bluetooth::gatt::GattRecord>::capacity() const noexcept {
  return cxxbridge1$rust_vec$bluetooth$gatt$GattRecord$capacity(this);
}
template <>
::bluetooth::gatt::GattRecord const *Vec<::bluetooth::gatt::GattRecord>::data() const noexcept {
  return cxxbridge1$rust_vec$bluetooth$gatt$GattRecord$data(this);
}
template <>
void Vec<::bluetooth::gatt::GattRecord>::reserve_total(::std::size_t new_cap) noexcept {
  return cxxbridge1$rust_vec$bluetooth$gatt$GattRecord$reserve_total(this, new_cap);
}
template <>
void Vec<::bluetooth::gatt::GattRecord>::set_len(::std::size_t len) noexcept {
  return cxxbridge1$rust_vec$bluetooth$gatt$GattRecord$set_len(this, len);
}
template <>
void Vec<::bluetooth::gatt::GattRecord>::truncate(::std::size_t len) {
  return cxxbridge1$rust_vec$bluetooth$gatt$GattRecord$truncate(this, len);
}
} // namespace cxxbridge1
} // namespace rust