ruble 0.0.3.alpha

data/ext/ruble/management/Registry.hpp

@@ -0,0 +1,170 @@
+#pragma once
+
+#include <memory>
+#include <iostream>
+#include <ranges>
+
+#include "types/declarations.hpp"
+#include "types/helpers.hpp"
+#include "types/ruby.hpp"
+#include "utils/ruby_context.hpp"
+#include "utils/human_type_names.hpp"
+#include "utils/garbage_collection.hpp"
+
+namespace ranges = std::ranges;
+namespace views = ranges::views;
+
+namespace RuBLE {
+    template<typename Key, class ProxyClass, class Value>
+    class Registry {
+        VALUE _self = Qnil;
+        std::shared_ptr<std::mutex> _mtx = nullptr;
+    public:
+        using Self [[maybe_unused]] = Registry<Key, ProxyClass, Value>;
+        using Owner = ProxyClass::Owner;
+        using Factory = RegistryFactory<Self>;
+        using KeyType = Key;
+        using ProxyClassType = ProxyClass;
+        using ProxyRubyObjType = ToRubyObjectResult<ProxyClass>;
+        using ValueType = Value;
+        using DataObject = Data_Object<ProxyClass>;
+        using Registry_DO = Data_Object<Self>;
+        using ProxyPtr = std::shared_ptr<ProxyClass>;
+//    using ProxyRefVector = std::vector<ProxyRef>;
+        using ProxyPtrVector = std::vector<ProxyPtr>;
+        using Collection = std::map<Key, ProxyPtr>;
+
+        using ForEachFn = std::function<void(typename Collection::mapped_type &)>;
+        using ForEachFnConst = std::function<void(typename Collection::mapped_type &)>;
+        static constexpr const bool is_owned = !std::is_same_v<Owner, nullptr_t>;
+
+        void ruby_mark() const {
+            rb_gc_mark(_self);
+            Rice::ruby_mark<Collection>(_registry.get());
+            for_each([](const ProxyPtr &ref) -> void {
+                Rice::ruby_mark<ProxyClass>(ref.get());
+            });
+        }
+
+    private:
+        Owner *_owner;
+        mutable std::shared_ptr<Collection> _registry;
+    protected:
+        explicit Registry(Owner *owner) :
+                     _owner(owner),
+                     _registry(std::make_shared<Collection>()),
+                     _mtx(std::make_shared<std::mutex>()),
+                     _self(Registry_DO(*this)) {
+//            std::cout << "Constructing new " << RuBLE::human_type_name<ProxyClass>() << " registry at address ";
+//            std::cout << to_hex_addr(this);
+//            if constexpr (is_owned) std::cout << " owned by " << human_type_name(*_owner); // _owner->to_s();
+//            std::cout << std::endl;
+        }
+        // FIXME: why am I getting a warning that _self is uninitialized with the constructor below?
+        Registry() requires std::is_same_v<Owner, nullptr_t> : Registry(nullptr) {}
+
+        Object self() const { return _self; }
+        constexpr const Owner *owner() const { return _owner; }
+        constexpr Owner *owner() { return _owner; }
+
+        [[maybe_unused]] Key key_from_value(const Value &) const {
+            std::cerr << "Type of class: " << RuBLE::Utils::human_type_name(*this) << std::endl;
+            throw std::invalid_argument(
+                    "key_from_value not implemented without .address() returning a BluetoothAddress");
+        }
+
+        [[maybe_unused]] BluetoothAddress key_from_value(const Value &v) const requires BluetoothAddressable<Value> {
+            return const_cast<Value &>(v).address();
+        }
+
+        [[maybe_unused]] BluetoothUUID key_from_value(const Value &v) const requires UUIDable<Value> {
+            return const_cast<Value &>(v).uuid();
+        }
+
+    public:
+        Collection::size_type size() const { return _registry->size(); }
+        bool contains(const auto &key) const { return _registry->contains(key); }
+        ProxyPtr &operator[](const Key &addr) { return _registry->at(addr); }
+        const ProxyPtr &operator[](const Key &addr) const { return _registry->at(addr); }
+        const ProxyPtr &at(const Key &addr) const { return _registry->at(addr); }
+        ProxyPtr &at(const Key &addr) { return _registry->at(addr); }
+        constexpr const Collection &data() const;
+
+        ProxyPtr fetch(const Value &value) const {
+            const std::lock_guard<std::mutex> lock(*_mtx); // needed to avoid race condition
+
+            Key key = key_from_value(value);
+            typename decltype(_registry)::element_type::iterator found = _registry->find(key);
+            if (found != _registry->end()) return found->second;
+
+            if (rb_during_gc()) {
+                std::ostringstream oss;
+                oss << "Warning: attempt to create new " << Utils::human_type_name<ProxyClass>();
+                oss << " at key " << key << " during garbage collection.";
+                throw std::runtime_error(oss.str());
+            }
+
+            if constexpr (is_owned) {
+                _registry->emplace(key, new ProxyClass(value, _owner));
+            } else {
+                _registry->emplace(key, new ProxyClass(value));
+            }
+            return _registry->at(key);
+        };
+
+        void clear() {
+            const std::lock_guard<std::mutex> lock(*_mtx); // needed to avoid race condition
+            _registry->clear();
+        }
+
+        ProxyPtrVector map_to_objects(const std::vector<Value> &unwrappedValues) const {
+            ProxyPtrVector result{};
+            std::ranges::transform(unwrappedValues, back_inserter(result), [this](const Value &v) -> ProxyPtr {
+                return this->fetch(v);
+            });
+            return result;
+        }
+
+        Rice::Array map_to_ruby_objects(const auto &arg) const requires HasRubyObject<ProxyClass> {
+            std::vector<ProxyPtr> proxyVec = map_to_objects(arg);
+            auto xform = [](const ProxyPtr &obj) -> Rice::Object { return obj->self(); };
+            auto objs = proxyVec | views::transform(xform);
+            Rice::Array result(objs.begin(), objs.end());
+            return result;
+        }
+
+        void for_each(auto fn) {
+            std::ranges::for_each(*_registry, [&fn](typename Collection::value_type &pair) -> void {
+                auto &[key, value] = pair;
+                fn(value);
+            });
+        }
+
+        void for_each(auto fn) const {
+            std::ranges::for_each(*_registry, [&fn](const typename Collection::value_type &pair) -> void {
+                const auto &[key, value] = pair;
+                fn(value);
+            });
+        }
+
+        [[nodiscard]] std::string to_s() const {
+            std::ostringstream os;
+            os << "Registry for " << Utils::human_type_name<ProxyClass>() << " (";
+            os << Utils::human_type_name(*this) << "): "; // << getSelf().inspect();
+            if constexpr (is_owned) os << " owned by " << _owner->to_s();
+            return os.str();
+        }
+
+        friend void Init_Registries();
+        template<typename> friend class RegistryFactory;
+
+        friend class std::hash<Registry<Key, ProxyClass, Value>>;
+    };
+
+    template<typename Key, class ProxyClass, class Value>
+    constexpr const Registry<Key, ProxyClass, Value>::Collection &Registry<Key, ProxyClass, Value>::data() const { return *_registry; }
+
+    extern std::shared_ptr<AdapterRegistry> adapterRegistry;
+}
+
+

data/ext/ruble/management/RegistryFactory.hpp

@@ -0,0 +1,113 @@
+#pragma once
+
+#include "types/declarations.hpp"
+#include "types/ruby.hpp"
+#include "types/helpers.hpp"
+#include "utils/hash.hpp"
+#include "utils/garbage_collection.hpp"
+#include <unordered_map>
+
+
+namespace RuBLE {
+// there is always a single singleton instance of this class,
+// but each instance holds a registry of registries (so to speak)
+// the keys of the meta-registry are hashes of Owner
+    template<class RegistryType>
+    class RegistryFactory {
+    public:
+        using Self [[maybe_unused]] = RegistryFactory<RegistryType>;
+
+        using RegistryOwner = RegistryType::Owner;
+        using RegistryMapKey = HashResultType<RegistryOwner>;
+        using RegistryMapValue = std::shared_ptr<RegistryType>;
+        using RegistryMapType = std::unordered_map<RegistryMapKey, RegistryMapValue>;
+
+        // no moving. only copying
+        RegistryFactory();
+        RegistryFactory(RegistryFactory &&) = delete;
+        RegistryFactory &operator=(RegistryFactory &&) = delete;
+        ~RegistryFactory() = default;
+
+    protected:
+        static constexpr HasherType<RegistryOwner> RegistryKeyHasher {};
+        inline static std::shared_ptr<Self> _instance {};
+        const std::shared_ptr<RegistryMapType> _registries {};
+
+    public:
+        static const std::shared_ptr<RegistryFactory> &instance();
+
+        const std::shared_ptr<RegistryType> &registry(RegistryOwner *owner) const;
+
+        const std::shared_ptr<RegistryType> &registry() const requires std::same_as<RegistryOwner, nullptr_t>;
+
+        template<class... Types>
+        [[maybe_unused]] static const std::shared_ptr<RegistryType> &getRegistry(const Types &... args);
+
+        void ruby_mark() const;
+    };
+
+    template<class RegistryType>
+    void RegistryFactory<RegistryType>::ruby_mark() const {
+        Rice::ruby_mark(_registries.get());
+        static constexpr auto mark_each_value = [](const RegistryMapValue &value) {
+            Rice::ruby_mark<RegistryType>(value.get());
+            rb_gc_mark(value->_self);
+        };
+        for (const auto &pair : *_registries) mark_each_value(pair.second);
+    }
+
+    template<class RegistryType>
+    template<class... Types>
+    const std::shared_ptr<RegistryType> &RegistryFactory<RegistryType>::getRegistry(const Types &... args) {
+        return instance()->registry(args...);
+    }
+
+    template<class RegistryType>
+    RegistryFactory<RegistryType>::RegistryFactory() : _registries(std::make_shared<RegistryMapType>()) {}
+
+    template<class RegistryType>
+    const std::shared_ptr<RegistryType> &
+    RegistryFactory<RegistryType>::registry() const requires std::same_as<RegistryOwner, nullptr_t> {
+        return this->registry(nullptr);
+    }
+
+    template<class RegistryType>
+    const std::shared_ptr<RegistryType> &RegistryFactory<RegistryType>::registry(RegistryOwner *owner) const {
+        RegistryMapKey index;
+        if constexpr (RegistryType::is_owned) {
+            index = RegistryKeyHasher(*owner);
+        } else {
+            index = RegistryKeyHasher(nullptr);
+        }
+        // happy path is registry at index already exists
+        if (_registries->contains(index)) return (*_registries)[index];
+
+        // using new RegistryType instead of std::make_shared allows keeping the constructor private
+        // will go out of scope later if try_emplace fails due to race condition
+        std::shared_ptr<RegistryType> newRegistry;
+        if constexpr (RegistryType::is_owned) {
+            newRegistry = std::shared_ptr<RegistryType>(new RegistryType(owner));
+        } else {
+            newRegistry = std::shared_ptr<RegistryType>(new RegistryType());
+        }
+        const auto &[registry_it, inserted] = _registries->try_emplace(index, std::move(newRegistry));
+        return registry_it->second;
+    }
+
+    template<class RegistryType>
+    const std::shared_ptr<RegistryFactory<RegistryType>> &RegistryFactory<RegistryType>::instance() {
+        static std::mutex _static_mtx;
+        if (!_instance) {
+            std::lock_guard<std::mutex> _lock(_static_mtx);
+            if (!_instance) _instance = std::shared_ptr<Self>(new Self());
+        }
+        return _instance;
+    }
+
+    extern std::shared_ptr<AdapterRegistryFactory> adapterRegistryFactory;
+    extern std::shared_ptr<PeripheralRegistryFactory> peripheralRegistryFactory;
+    extern std::shared_ptr<ServiceRegistryFactory> serviceRegistryFactory;
+    extern std::shared_ptr<CharacteristicRegistryFactory> characteristicRegistryFactory;
+}
+
+

data/ext/ruble/management/RubyQueue.cpp

@@ -0,0 +1,152 @@
+#include "management/RubyQueue.hpp"
+#include "utils/ruby_context.hpp"
+#include "utils/async.hpp"
+#include <ruby/thread.h>
+
+using namespace std::chrono_literals;
+namespace RuBLE {
+    constinit std::shared_ptr<RubyQueue> RubyQueue::_instance {};
+
+    const std::shared_ptr<RubyQueue> &RubyQueue::instance() {
+        if (!_instance) _instance = std::shared_ptr<RubyQueue>(new RubyQueue());
+        return _instance;
+    }
+
+    Rice::Object RubyQueue::rb_thread() const {
+        return { _rb_thread.load() };
+    }
+
+    void RubyQueue::start() {
+        if (!_starting.test_and_set()) {
+//            if constexpr (DEBUG) std::cerr << "Starting RubyQueue" << std::endl;
+            RbThreadCreateFn<void> runThread = [](void *rubyQueuePtr) -> VALUE {
+                reinterpret_cast<RubyQueue*>(rubyQueuePtr)->run();
+                return Qnil;
+            };
+            // TODO: figure out how/if to handle case where thread creation fails
+            // TODO: wrap this in rice's `protect` fn
+            RubyThreadId tid = rb_thread_create(runThread, this);
+            if constexpr (DEBUG) std::cerr << "RubyQueue thread ID: " << tid << std::endl;
+            _rb_thread.store(tid);
+        }
+    }
+    void RubyQueue::ensure_started() {
+        if (Utils::wait_until([&]{ return _startup_latch.try_acquire(); }, 15s)) {
+//            std::cout << "RubyQueue started." << std::endl;
+//            std::cerr << "RuBLE queue start ensured." << std::endl;
+            return;
+        }
+
+        std::cerr << "RuBLE queue failed to start. Killing it." << std::endl;
+        kill();
+        throw std::runtime_error("RuBLE queue failed to start. Aborting.");
+    }
+
+    VALUE RubyQueue::run() {
+        // TODO: add thread unblocking handlers
+        auto loopFn = [](void *rqPtr) -> void * {
+//            std::cout << "About to call RubyQueue::loop" << std::endl;
+            reinterpret_cast<RubyQueue*>(rqPtr)->loop();
+            return nullptr;
+        };
+        auto ubf = [](void *rqPtr) -> void {
+            reinterpret_cast<RubyQueue*>(rqPtr)->stop();
+        };
+        rb_thread_call_without_gvl(loopFn, this, ubf, this);
+        return Qnil;
+    }
+
+    void RubyQueue::loop() {
+        std::lock_guard lck(_run_mtx);
+
+        _thread_id.store(std::this_thread::get_id());
+        _startup_latch.release();
+        _running.test_and_set();
+//        std::cerr << "RuBLE::RubyQueue has started." << std::endl;
+
+        QueueItemType item;
+        while (!_stopping.test()) {
+            _sem.acquire();
+            if (_stopping.test()) break;
+
+            {
+                std::lock_guard<std::mutex> lock(_mtx);
+                if constexpr (DEBUG) assert(!_q->empty());
+                item = std::move(_q->back());
+                _q->pop_back();
+            }
+
+            rb_thread_call_with_gvl([](void *queueItem) -> void * {
+                auto in_ruby_guard = in_ruby.assert_in_ruby_guard();
+                (*reinterpret_cast<QueueItemType*>(queueItem))();
+                return nullptr;
+            }, &item);
+        }
+        _running.clear();
+//        std::cout << "RubyQueue::loop exiting" << std::endl;
+    }
+
+    void RubyQueue::push(QueueItemType fn) {
+        if (_stopping.test()) {
+            if (DEBUG) {
+                std::cerr << "Warning: attempted to push to RuBLE callback queue, " <<
+                          "but queue has been stopped. Refusing to push." << std::endl;
+                std::cerr << "C++ Backtrace:" << std::endl << boost::stacktrace::stacktrace() << std::endl;
+                return;
+            }
+        }
+
+        {
+            std::lock_guard<std::mutex> lck(_mtx);
+            _q->emplace_back(std::move(fn));
+        }
+        _sem.release();
+    }
+
+    void RubyQueue::stop() {
+        if (!_stopping.test_and_set()) {
+//            std::cerr << "Signalling RubyQueue to stop" << std::endl;
+            _sem.release(); // if stop flag wasn't set before, notify cv
+        }
+        std::this_thread::yield();
+    }
+
+    // This is ensured to be accurate because it only returns true if
+    // the _running std::atomic_flag is set AND the _run_mtx can't be acquired
+    bool RubyQueue::running() const {
+        if (!_running.test()) return false;
+
+        // using a shared lock here means we don't have to worry about
+        // multiple simultaneous calls to RubyQueue::running causing issues
+        std::shared_lock<std::shared_mutex> lck(_run_mtx, std::defer_lock);
+        // if we were are able to acquire the shared lock, obviously the queue isn't holding it
+        // if so, we clear _running, because this means the queue previously set _running,
+        // but isn't any longer
+        if (lck.try_lock()) _running.clear();
+        return !lck;
+    }
+
+    // returns if _stopping was requested AND we're not running
+    bool RubyQueue::stopped() const {
+        return _stopping.test() && !running();
+    }
+
+    void RubyQueue::stop_on_exit(VALUE) {
+        std::shared_ptr<RubyQueue> rq = instance();
+
+        rq->stop();
+        if (rq->stopped()) return;
+
+        if (Utils::wait_until([&]{ return !rq->running(); }, 1s)) return;
+
+        std::cerr << "RuBLE::RubyQueue won't exit. Forcing it.." << std::endl;
+        rq->kill();
+    }
+
+    void RubyQueue::kill() {
+        stop();
+        if (rb_thread().test()) rb_thread_kill(rb_thread());
+        // TODO: is there any way to join threads? ruby's thread join functions
+        //  don't seem to be exported (I guess we can use Rice::Object#call)
+    }
+}

data/ext/ruble/management/RubyQueue.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+#include "containers/Callback.hpp"
+#include "types/stl.hpp"
+#include <deque>
+#include <mutex>
+#include <chrono>
+#include <thread>
+#include <shared_mutex>
+
+
+namespace RuBLE {
+    // All ruby calls must take place in thread known to ruby (i.e. where rb_get_execution_context works)
+    // Since SimpleBLE creates its own thread from which callbacks are invoked,
+    // we have that (non-ruby) thread add a function to RubyQueue,
+    // which is monitored from a ruby thread and invoked immediately invoked with a FIFO ordering
+    class RubyQueue {
+    public:
+        using FnType = std::function<void(void)>;
+        using QueueItemType = FnType;
+        // TODO: perhaps switch to https://www.boost.org/doc/libs/1_83_0/doc/html/boost/lockfree/queue.html
+        // to reduce the need for atomics/etc?
+        using QueueType = std::deque<QueueItemType>;
+
+    private:
+        static std::shared_ptr<RubyQueue> _instance;
+        std::shared_ptr<QueueType> _q = std::shared_ptr<QueueType>(new QueueType());
+
+        std::mutex _mtx;
+        Semaphore _sem { 0 };
+        std::binary_semaphore _startup_latch { 0 };
+
+        mutable std::shared_mutex _run_mtx;
+        mutable std::atomic_flag _running;
+
+        std::atomic<CppThreadId> _thread_id;
+        std::atomic<RubyThreadId> _rb_thread;
+        std::atomic_flag _starting, _stopping;
+
+        constexpr RubyQueue() = default;
+        VALUE run();
+        void loop();
+    public:
+        ~RubyQueue() = default;
+        RubyQueue(const RubyQueue&) = delete;
+        RubyQueue(RubyQueue&&) = delete;
+        RubyQueue &operator=(RubyQueue&&) = delete;
+        RubyQueue &operator=(const RubyQueue&) = delete;
+        // TODO: add a function that waits for queue to be settled
+
+        static const std::shared_ptr<RubyQueue> &instance();
+        [[nodiscard]] Object rb_thread() const;
+
+        void push(QueueItemType fn);
+
+        void start();
+        void ensure_started();
+        [[nodiscard]] bool running() const;
+
+        void stop();
+        [[nodiscard]] bool stopped() const;
+        static void stop_on_exit(VALUE); // Argument is unused, but rb_set_end_proc requires it
+        void kill();
+    };
+
+//    using RubyQueue_DT = Data_Type<RubyQueue>;
+//    using RubyQueue_DO = Data_Object<RubyQueue>;
+//    static inline RubyQueue_DT rb_cRubyQueue;
+}

data/ext/ruble/modularize.diff

@@ -0,0 +1,28 @@
+64c64,68
+<     include(FetchContent)
+---
+>     set(BOOST_REPO "https://github.com/boostorg/boost")
+>     set(BOOST_TAG boost-1.83.0)
+>     cmake_path(SET BOOST_CACHE_LOCATION NORMALIZE "${CMAKE_SOURCE_DIR}/tmp/${BOOST_TAG}")
+>     set(BOOST_INCLUDE_LIBRARIES "stacktrace;exception;headers;endian;algorithm;core;describe")
+> 
+70d73
+<     set(BOOST_INCLUDE_LIBRARIES "stacktrace;exception;headers;endian;algorithm;core;describe")
+78a82,83
+> 
+>     include(FetchContent)
+81,84c86,88
+<         # TODO: put this somewhere outside the build tree so it stays cached
+<         SOURCE_DIR ../../tmp/boost-git-cache
+<         GIT_REPOSITORY "https://github.com/boostorg/boost" # TODO: would an archive make more sense(?)
+<         GIT_TAG boost-1.83.0 # TODO: set this in build-config.cmake
+---
+>         SOURCE_DIR "${BOOST_CACHE_LOCATION}"
+>         GIT_REPOSITORY ${BOOST_REPO} # TODO: would an archive make more sense(?)
+>         GIT_TAG ${BOOST_TAG} # TODO: set this in build-config.cmake
+103,104c107,108
+<     target_link_libraries(${build_target} INTERFACE Boost::headers Boost::exception Boost::describe)
+<     target_link_libraries(${build_target} PRIVATE Boost::algorithm Boost::core)
+---
+>     target_link_libraries(${build_target} INTERFACE Boost::headers Boost::exception Boost::describe Boost::endian)
+>     target_link_libraries(${build_target} PRIVATE Boost::algorithm Boost::core Boost::endian)

data/ext/ruble/types/SimpleBLE.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <simpleble/SimpleBLE.h>
+#include <simpleble/Adapter.h>
+#include <simpleble/Characteristic.h>
+
+namespace RuBLE {
+    using BluetoothAddress = SimpleBLE::BluetoothAddress;
+    using BluetoothAddressType = SimpleBLE::BluetoothAddressType;
+    using BluetoothUUID = SimpleBLE::BluetoothUUID;
+
+    template<typename T>
+    concept BluetoothAddressable = requires(T t) {
+        { t.address() } -> std::same_as<SimpleBLE::BluetoothAddress>;
+    };
+
+    template<typename T>
+    concept UUIDable = requires(T t) {
+        { t.uuid() } -> std::same_as<SimpleBLE::BluetoothUUID>;
+    };
+}

data/ext/ruble/types/declarations.hpp

@@ -0,0 +1,91 @@
+#pragma once
+
+#include "config.h"
+#ifdef HAVE_VALGRIND
+#include <valgrind/valgrind.h>
+#endif
+
+// from https://stackoverflow.com/a/6713727
+// #define STRINGIFICATOR(X) #X
+#include "types/SimpleBLE.hpp"
+
+namespace Rice {
+    class String;
+    class Array;
+    class Object;
+    template<typename T>
+    class Data_Type;
+    template<typename T>
+    class Data_Object;
+    template<typename Enum_T>
+    class Enum;
+}
+
+namespace RuBLE {
+#ifdef RUBLE_DEBUG
+    static constexpr const bool DEBUG = true;
+#else
+    static constexpr const bool DEBUG = false;
+#endif
+
+    template<const auto &FIELD_NAMES>
+    class NamedBitSet;
+
+    using str_char_type [[maybe_unused]] = std::string::value_type;
+
+    class RubyQueue;
+
+    class Callback;
+    template<typename Key, class ProxyClass, class Value>
+    class Registry;
+
+    template<class RegistryType>
+    class RegistryFactory;
+
+    using BluetoothAddressType_DT = Rice::Enum<SimpleBLE::BluetoothAddressType>;
+
+    class ByteArray;
+    using ByteArray_DT = Rice::Data_Type<ByteArray>;
+    using ByteArray_DO = Rice::Data_Object<ByteArray>;
+
+    class Adapter;
+    using Adapter_DT = Rice::Data_Type<Adapter>;
+    using Adapter_DO = Rice::Data_Object<Adapter>;
+    using AdapterRegistry = Registry<SimpleBLE::BluetoothAddress, Adapter, SimpleBLE::Adapter>;
+    using AdapterRegistry_DT = Rice::Data_Type<AdapterRegistry>;
+    using AdapterRegistry_DO [[maybe_unused]] = Rice::Data_Object<AdapterRegistry>;
+    using AdapterRegistryFactory = RegistryFactory<AdapterRegistry>;
+
+    class Peripheral;
+    using Peripheral_DT = Rice::Data_Type<Peripheral>;
+    using Peripheral_DO = Rice::Data_Object<Peripheral>;
+    using PeripheralRegistry = Registry<SimpleBLE::BluetoothAddress, Peripheral, SimpleBLE::Peripheral>;
+    using PeripheralRegistry_DT = Rice::Data_Type<PeripheralRegistry>;
+    using PeripheralRegistry_DO [[maybe_unused]] = Rice::Data_Object<PeripheralRegistry>;
+    using PeripheralRegistryFactory = RegistryFactory<PeripheralRegistry>;
+
+    class Service;
+    using Service_DT = Rice::Data_Type<Service>;
+    using Service_DO [[maybe_unused]] = Rice::Data_Object<Service>;
+    using ServiceRegistry = Registry<SimpleBLE::BluetoothUUID, Service, SimpleBLE::Service>;
+    using ServiceRegistry_DT = Rice::Data_Type<ServiceRegistry>;
+    using ServiceRegistry_DO [[maybe_unused]] = Rice::Data_Object<ServiceRegistry>;
+    using ServiceRegistryFactory = RegistryFactory<ServiceRegistry>;
+
+    class Characteristic;
+    using Characteristic_DT = Rice::Data_Type<Characteristic>;
+    using Characteristic_DO [[maybe_unused]] = Rice::Data_Object<Characteristic>;
+    using CharacteristicRegistry = Registry<SimpleBLE::BluetoothUUID, Characteristic, SimpleBLE::Characteristic>;
+    using CharacteristicRegistry_DT = Rice::Data_Type<CharacteristicRegistry>;
+    using CharacteristicRegistry_DO [[maybe_unused]] = Rice::Data_Object<CharacteristicRegistry>;
+    using CharacteristicRegistryFactory = RegistryFactory<CharacteristicRegistry>;
+
+    enum class CharacteristicCapabilityType : std::size_t;
+    using CharacteristicCapabilityType_DT = Rice::Enum<CharacteristicCapabilityType>;
+    using CharacteristicCapabilityType_DO [[maybe_unused]] = Rice::Data_Object<CharacteristicCapabilityType>;
+
+    class Descriptor;
+    using Descriptor_DT = Rice::Data_Type<Descriptor>;
+    using Descriptor_DO = Rice::Data_Object<Descriptor>;
+
+}

data/ext/ruble/types/helpers.hpp

@@ -0,0 +1,12 @@
+#pragma once
+#include <concepts>
+
+namespace std {
+    struct nullopt_t; // NOLINT(*-dcl58-cpp)
+}
+
+namespace RuBLE::Utils {
+    template<typename T>
+    constexpr bool is_nullopt = std::same_as<std::remove_cvref_t<T>, std::nullopt_t>;
+}
+