ruble 0.0.3.alpha

data/ext/ruble/config.h.in

@@ -0,0 +1,25 @@
+#cmakedefine EXTENSION_NAME "@EXTENSION_NAME@"
+#cmakedefine EXTENSION_VERSION "@EXTENSION_VERSION@"
+#cmakedefine RUBY_VERSION "@RUBY_VERSION@"
+#cmakedefine RICE_VERSION "@RICE_VERSION@"
+
+// TODO: defer to single point of truth re: min ruby version elsewhere.
+//   e.g. minimum version already in `.gemspec` and CMakeLists
+
+#cmakedefine RUBLE_DEBUG 1
+#cmakedefine HAVE_VALGRIND 1
+
+#cmakedefine BOOST_STACKTRACE_USE_BACKTRACE 1
+#cmakedefine BOOST_STACKTRACE_USE_ADDR2LINE 1
+#cmakedefine BOOST_STACKTRACE_USE_BASIC 1
+#cmakedefine BOOST_STACKTRACE_USE_WINDBG 1
+#cmakedefine BOOST_STACKTRACE_USE_WINDBG_CACHED 1
+#cmakedefine BOOST_STACKTRACE_USE_NOOP 1
+#cmakedefine BOOST_STACKTRACE_LINK 1
+#cmakedefine BOOST_STACKTRACE_ADDR2LINE_LOCATION "@BOOST_STACKTRACE_ADDR2LINE_LOCATION@"
+#cmakedefine BOOST_STACKTRACE_BACKTRACE_INCLUDE_FILE "@BOOST_STACKTRACE_BACKTRACE_INCLUDE_FILE@"
+
+#ifdef BOOST_STACKTRACE_LINK
+    #define BOOST_ENABLE_ASSERT_DEBUG_HANDLER 1
+#endif
+

data/ext/ruble/containers/ByteArray.cpp

@@ -0,0 +1,64 @@
+#include "types/declarations.hpp"
+#include "containers/ByteArray.hpp"
+
+#include "utils/containers.hpp"
+
+namespace RuBLE {
+
+    ByteArray::ByteArray(Object obj) : ByteArray() {
+        if (obj.is_a(rb_cByteArray)) {
+            *this = { *ByteArray_DO(obj).get() };
+        } else if(obj.is_a(rb_cNumeric)) {
+            *this = { rb_num2ulong(obj) };
+        } else if (obj.is_a(rb_cString) || obj.is_a(rb_cSymbol)) {
+            *this = {Rice::String(obj).str()};
+        } else if(obj.is_a(rb_cNilClass) || obj.is_a(rb_cTrueClass) || obj.is_a(rb_cFalseClass)) {
+            *this = { obj.test() };
+        } else {
+            throw std::invalid_argument("Cannot convert "s + obj.inspect().str() + " to a ByteArray");
+        }
+    }
+
+    ByteArray ByteArray::from_ruby(Object obj) {
+        return { std::move(obj) };
+    }
+
+    std::string ByteArray::to_s() const {
+        std::ostringstream oss;
+        oss << Utils::basic_object_inspect_start(*this) << " ";
+        oss << Utils::to_hex_data(_data);
+        oss << " (" << Utils::ruby_quote_string(_data) << ")>";
+        return oss.str();
+    }
+
+    std::string ByteArray::inspect() const { return to_s(); }
+
+    void ByteArray::ruby_mark() const {
+        Rubyable::ruby_mark();
+    }
+
+    void Init_ByteArray() {
+        rb_cByteArray = define_class_under<ByteArray>(rb_mRuBLE, "ByteArray")
+                .define_singleton_function("new", &ByteArray::from_ruby)
+                .define_method("get", &ByteArray::to_string)
+                .define_method("to_s", &ByteArray::to_s)
+                .define_method("inspect", &ByteArray::inspect)
+                .define_method("data", &ByteArray::data)
+                .define_method("to_i", &ByteArray::to_i<>)
+                .define_method("%", &ByteArray::operator%<>)
+                .define_method("&", &ByteArray::operator&<>)
+                .define_method("|", &ByteArray::operator|<>)
+                .define_method("~", &ByteArray::operator~)
+                .define_method("!", &ByteArray::operator!)
+                .define_method("<=>", &ByteArray::operator<=><>)
+                ;
+    }
+}
+
+//namespace Rice::detail {
+//    bool From_Ruby<RuBLE::ByteArray>::can_convert_from_ruby(VALUE obj) {
+//        return std::find(supported_ruby_types.cbegin(),
+//                         supported_ruby_types.cend(),
+//                         rb_type(obj)) != supported_ruby_types.cend();
+//    }
+//}

data/ext/ruble/containers/ByteArray.hpp

@@ -0,0 +1,161 @@
+#pragma once
+
+#include "types/declarations.hpp"
+#include "types/ruby.hpp"
+#include "types/helpers.hpp"
+#include "utils/containers.hpp"
+#include "utils/hexadecimal.hpp"
+#include "utils/human_type_names.hpp"
+#include "concerns/Rubyable.hpp"
+#include <utility>
+#include <array>
+#include <algorithm>
+#include <compare>
+#include <cstdlib>
+#include <boost/endian/conversion.hpp>
+
+namespace RuBLE {
+    template<typename T>
+    concept UnsignedIntegral = std::is_integral_v<T> && std::is_unsigned_v<T>;
+
+    // TODO: Need to test this out
+    class ByteArray : public Rubyable<ByteArray> {
+    public:
+        using DataObject = ByteArray_DO;
+    private:
+        SimpleBLE::ByteArray _data;
+
+    public:
+        using char_type = SimpleBLE::ByteArray::value_type;
+        using iterator_diff_type = typename std::iterator_traits<SimpleBLE::ByteArray::const_iterator>::difference_type;
+
+        static constexpr const std::size_t char_size = sizeof(char_type);
+
+        template<typename T>
+        static constexpr const std::size_t chars_per_val = ([]() -> std::size_t {
+            std::size_t quot = sizeof(T) / char_size;
+            std::size_t rem  = sizeof(T) % char_size;
+            return quot + (rem > 0 ? 1 : 0);
+        })();
+
+        using default_integral_type = uint64_t;
+
+        [[nodiscard]] constexpr ByteArray();
+        constexpr ByteArray(SimpleBLE::ByteArray byteArray);
+
+        ByteArray(Rice::Object obj);
+        template<UnsignedIntegral T>
+        ByteArray(const T &data) : ByteArray() {
+            // TODO: modernize by using std::span
+            _data.assign(chars_per_val<T>, '\0');
+            UnsignedIntegral auto &dstVal = *reinterpret_cast<T *>(_data.data());
+            dstVal = boost::endian::native_to_little(data);
+        }
+
+        constexpr ByteArray(const char_type &chr);
+        constexpr ByteArray(const bool &b);
+
+        static ByteArray from_ruby(Rice::Object obj);
+
+        [[nodiscard]] constexpr std::size_t length() const { return _data.size(); }
+        [[nodiscard]] constexpr std::size_t byte_count() const { return length() * char_size; }
+
+        template<UnsignedIntegral T>
+        constexpr explicit operator T() const { return to_i<T>(); }
+
+        template<UnsignedIntegral T = default_integral_type>
+        constexpr T operator|(const T &other) const { return to_i<T>() | other; }
+
+        template<UnsignedIntegral T = default_integral_type>
+        constexpr T operator&(const T &other) const { return to_i<T>() & other; }
+
+        template<UnsignedIntegral T = default_integral_type>
+        constexpr T operator^(const T &other) const { return to_i<T>() ^ other; }
+
+        template<UnsignedIntegral T = default_integral_type>
+        constexpr T operator%(const T &other) const { return to_i<T>() % other; }
+
+        constexpr bool operator!() const { return to_i<>() != 0; }
+
+        constexpr auto operator~() const { return ~to_i<>(); }
+
+        template<typename T = default_integral_type>
+        constexpr int operator<=>(const T &other) const {
+            std::strong_ordering result = to_i<T>() <=> other;
+            if (result == std::strong_ordering::less) return -1;
+            if (result == std::strong_ordering::greater) return 1;
+            return 0;
+        }
+
+        constexpr std::strong_ordering operator<=>(const ByteArray &other) const {
+            return _data <=> other._data;
+        }
+        constexpr bool operator==(const ByteArray &other) const {
+            auto comparison = *this <=> other;
+            return comparison == std::strong_ordering::equivalent || comparison == std::strong_ordering::equal;
+        }
+
+        constexpr bool operator!=(const ByteArray &other) const { return !(*this == other); }
+
+        [[nodiscard]] constexpr std::string to_string() const { return _data; }
+        [[nodiscard]] std::string to_s() const;
+        [[nodiscard]] std::string inspect() const;
+
+        [[nodiscard]] constexpr const SimpleBLE::ByteArray &data() const { return _data; }
+
+        [[nodiscard]] constexpr const std::byte &operator[](iterator_diff_type pos) const {
+            assert(pos < byte_count() && pos >= 0);
+            const void *bytesVoid = _data.data();
+            const std::byte *bytes = static_cast<const std::byte*>(bytesVoid);
+            return bytes[pos];
+        }
+
+        constexpr operator const SimpleBLE::ByteArray &() const { return _data; }
+        // TODO: test me!
+        template<UnsignedIntegral T = default_integral_type>
+        [[nodiscard]] T to_i() const {
+            if (sizeof(T) < char_size * length()) {
+                static constexpr const auto errfmt = "Integer type %s holds only %ld bytes, "\
+                    "while %s contains %ld bytes of data. Result will be truncated.";
+                rb_warn(errfmt, std::string(Utils::human_type_name<T>()).c_str(), sizeof(T),
+                        std::string(Utils::human_type_name(*this)).c_str(), char_size * length());
+            }
+            const UnsignedIntegral auto &val = *reinterpret_cast<const T*>(_data.data());
+            return boost::endian::little_to_native(val);
+        }
+
+        void ruby_mark() const;
+    };
+
+    constexpr ByteArray::ByteArray() : _data(), Rubyable<ByteArray>() {}
+
+    constexpr ByteArray::ByteArray(SimpleBLE::ByteArray byteArray) :
+            _data(std::move(byteArray)), Rubyable<ByteArray>() {}
+
+    constexpr ByteArray::ByteArray(const ByteArray::char_type &chr) : ByteArray(std::string(chr, 1)) {}
+
+    constexpr ByteArray::ByteArray(const bool &b) : ByteArray(b ? '1' : '0') {}
+
+
+    void Init_ByteArray();
+}
+
+//namespace Rice::detail {
+//    template<>
+//    class From_Ruby<RuBLE::ByteArray> {
+//    public:
+//        static constexpr const auto supported_ruby_types =
+//                std::to_array({T_BIGNUM, T_FIXNUM, T_SYMBOL, T_STRING, T_NIL, T_TRUE, T_FALSE});
+//        static bool can_convert_from_ruby(VALUE obj);
+//        bool is_convertible(VALUE value) { // NOLINT(*-convert-member-functions-to-static)
+//            return can_convert_from_ruby(value);
+//        }
+//        RuBLE::ByteArray convert(VALUE value) { // NOLINT(*-convert-member-functions-to-static)
+//            return RuBLE::ByteArray::from_ruby(value);
+//        }
+//    };
+//}
+
+constexpr std::ostream &operator<<(std::ostream &os, const RuBLE::ByteArray &cba) {
+    return os << cba.data();
+}

data/ext/ruble/containers/Callback.hpp

@@ -0,0 +1,52 @@
+#pragma once
+#include "types/declarations.hpp"
+#include "types/ruby.hpp"
+#include "utils/RubyCallbackTraits.hpp"
+#include "utils/garbage_collection.hpp"
+
+using namespace std::string_literals;
+namespace RuBLE {
+    struct Callback {
+    protected:
+        std::size_t  _arg_count;
+        VALUE _cb = Qnil;
+    public:
+        explicit Callback(const std::size_t &arg_count) : _arg_count(arg_count) {}
+
+        // TODO: confirm this is a proc (taking the right number of args)
+        constexpr void set(VALUE cb) {
+            Ruby::CallbackTraits::assert_accepts_n_args(cb, _arg_count, true);
+            _cb = cb;
+        }
+
+        [[maybe_unused]] [[nodiscard]] constexpr const std::size_t &arg_count() const { return _arg_count; }
+
+        [[maybe_unused]] constexpr void clear() { set(Qnil); }
+
+        template<class... Types>
+        Object fire(const Types& ...args) {
+            if constexpr (DEBUG) assert(sizeof...(Types) == arg_count());
+
+            Object cb(_cb);
+            if (!cb.test()) return Qnil;
+            const std::initializer_list<Object> argList { args... };
+            Rice::Array argArray(argList.begin(), argList.end());
+            return cb.vcall("call", argArray);
+        }
+
+        constexpr operator bool() const {
+            return _cb != Qnil && _cb != Qfalse;
+        }
+
+        constexpr void ruby_mark() const {
+            if (*this) rb_gc_mark(_cb);
+        }
+    };
+}
+
+namespace Rice {
+    template<>
+    constexpr void ruby_mark<RuBLE::Callback>(RuBLE::Callback *cb) { cb->ruby_mark(); }
+}
+
+

data/ext/ruble/containers/NamedBitSet.hpp

@@ -0,0 +1,140 @@
+#pragma once
+
+#include <cstddef>
+#include <map>
+#include <bitset>
+#include <utility>
+#include <functional>
+#include <variant>
+#include <string_view>
+#include <ranges>
+#include "utils/containers.hpp"
+
+#include "types/helpers.hpp"
+
+namespace RuBLE {
+    template<const auto &FIELD_NAMES> class NamedBitSet;
+}
+
+template<const auto &FIELDS> struct std::hash<RuBLE::NamedBitSet<FIELDS>> {
+    constexpr std::size_t operator()(const RuBLE::NamedBitSet<FIELDS> &nbs) const noexcept;
+};
+
+namespace RuBLE {
+    // this namespace from https://en.cppreference.com/w/cpp/utility/variant/visit
+    namespace visit {
+        template<class... Ts>
+        struct overloaded : Ts... { using Ts::operator()...; };
+#if !defined(__cpp_deduction_guides) || __cpp_deduction_guides < 201907L
+        // explicit deduction guide (not needed as of C++20)
+        template<class... Ts>
+        overloaded(Ts...) -> overloaded<Ts...>;
+#endif
+    }
+
+    namespace FlagCheck {
+        using ConstFlag = bool;
+        using StaticFn = const std::function<bool()>;
+        template<class T> using ConstMemFn = std::function<bool(const std::remove_cvref_t<T>&)>;
+
+        template<class T = nullptr_t>
+        using Fn = std::variant<ConstFlag, StaticFn, ConstMemFn<T>>;
+
+        using MapKey = std::string_view;
+        template<class T = nullptr_t> using MapType = std::map<MapKey, Fn<T>>;
+
+        template<class R, class T>
+        concept Map = requires(const R &r, T &t) {
+            { std::get<0>(*r.begin()) } -> std::convertible_to<const MapKey>;
+            { std::get<1>(*r.begin()) } -> std::convertible_to<Fn<T>>;
+        };
+
+#ifdef NBSDEBUG
+        template<class T = nullptr_t> using Pair = std::pair<const MapKey, Fn<T>>;
+        template<class T> using MapPairType = FlagCheck::Pair<T>;
+        template <class R> using RangeIteratorType = std::result_of_t<decltype(&R::cbegin)(R)>;
+        template<class R> using RangeItem = std::result_of_t<decltype(&RangeIteratorType<R>::operator*)(RangeIteratorType<R>)>;
+        template<class R> using RangeItemNoRef = std::remove_reference_t<RangeItem<R>>;
+        template<class R> using RangeItemKey = RangeItemNoRef<R>::first_type;
+        template<class R> using RangeItemValue = RangeItemNoRef<R>::second_type;
+        static_assert(std::is_same_v<MapType<int>::value_type, Pair<int>>);
+        static_assert(std::is_convertible_v<RangeItem<MapType<int>>, MapPairType<int>>);
+        static_assert(std::is_convertible_v<RangeItemKey<MapType<int>>, const MapKey&>);
+        static_assert(Map<MapType<int>, int>);
+#endif
+
+        template<class T>
+        bool test_flag(const FlagCheck::Fn<T> &fn, const auto &obj = nullptr) {
+            bool result = std::visit(visit::overloaded{
+                    []() -> bool { return false; },
+                    [](nullptr_t) -> bool { return false; },
+                    [](const FlagCheck::ConstFlag &val) -> bool { return val; },
+                    [](const FlagCheck::StaticFn &fn)  -> bool { return fn(); },
+                    [&obj](const std::function<bool(const T&)> &fn) -> bool {
+                        return fn(obj);
+                    },
+            }, fn);
+            return result;
+        }
+
+    }
+    template<const auto& FIELD_NAMES>
+    class NamedBitSet {
+    public:
+        static constexpr auto FIELDS = std::to_array<const std::string_view>(FIELD_NAMES);
+        static constexpr const std::size_t N = FIELDS.size();
+        using BitSet = std::bitset<N>;
+        using BitRef = BitSet::reference;
+        using PairType = std::pair<std::string_view, std::size_t>;
+        static constexpr auto PAIRS = ([]<std::size_t... I>(std::index_sequence<I...>) -> std::array<PairType, N> {
+            return {std::make_pair(FIELD_NAMES[I], I)...};
+        })(std::make_index_sequence<N>{});
+
+        static constexpr std::size_t index_of(const std::string_view &name);
+
+    private:
+        BitSet _bits = 0;
+
+    public:
+        constexpr const BitSet &bits() const;
+
+        constexpr BitRef operator[](const std::string_view &name);
+
+        constexpr bool operator[](const std::string_view &name) const;
+
+        // Ensure T is an integral type that can hold all N bits
+        template<typename T> requires std::is_integral_v<T> && (std::numeric_limits<T>::max() >= (1 << N) - 1)
+                constexpr explicit operator T() const { return static_cast<T>(_bits.to_ullong()); }
+
+        [[nodiscard]] constexpr std::vector<std::string_view> flag_names() const;
+
+        [[nodiscard]] constexpr std::vector<std::string> flag_name_strs() const;
+
+        constexpr NamedBitSet(): _bits(0) {}
+
+        constexpr NamedBitSet(const std::initializer_list<const std::string_view> &list);
+
+        constexpr NamedBitSet(const auto &rangeList);
+        constexpr NamedBitSet(const BitSet &bitSet);
+        // Takes a map (or equivalent) of 'std::string_view's to one of: boolean literal, static fn, const mem fn, mem fn
+        template<typename ObjT, FlagCheck::Map<ObjT> R>
+        constexpr NamedBitSet(R &r, ObjT &&obj);
+
+        [[nodiscard]] constexpr std::string to_s() const;
+    };
+
+
+
+#ifdef RUBLE_DEBUG
+    void NamedBitSetDemo();
+#endif
+}
+
+template<const auto &FIELDS>
+constexpr std::size_t std::hash<RuBLE::NamedBitSet<FIELDS>>::operator()(const RuBLE::NamedBitSet<FIELDS> &nbs) const noexcept {
+    std::size_t h1 = typeid(nbs).hash_code();
+    static auto hasher = std::hash<decltype(RuBLE::NamedBitSet<FIELDS>::BitSet)>{};
+    return h1 ^ (hasher(nbs.bits()) << 1);
+}
+
+#include "NamedBitSet.ipp"

data/ext/ruble/containers/NamedBitSet.ipp

@@ -0,0 +1,71 @@
+#pragma once
+
+#include "types/declarations.hpp"
+#include "NamedBitSet.hpp"
+
+#include <string>
+#include "utils/containers.hpp"
+using namespace std::string_literals;
+
+namespace RuBLE {
+    template<const auto &FIELD_NAMES>
+    constexpr std::string NamedBitSet<FIELD_NAMES>::to_s() const { return Utils::join(flag_names(), "|"); }
+
+    template<const auto &FIELD_NAMES>
+    template<typename ObjT, FlagCheck::Map<ObjT> R>
+    [[maybe_unused]]
+    constexpr NamedBitSet<FIELD_NAMES>::NamedBitSet(R &r, ObjT &&obj) {
+        for (const auto &[name, fn] : r) (*this)[name] = FlagCheck::test_flag<ObjT>(fn, obj);
+    }
+
+    template<const auto &FIELD_NAMES>
+    constexpr NamedBitSet<FIELD_NAMES>::NamedBitSet(const NamedBitSet::BitSet &bitSet) : _bits(bitSet) {}
+
+    template<const auto &FIELD_NAMES>
+    constexpr NamedBitSet<FIELD_NAMES>::NamedBitSet(const auto &rangeList) {
+        for (const auto &sv: rangeList) (*this)[sv] = true;
+    }
+
+    template<const auto &FIELD_NAMES>
+    constexpr NamedBitSet<FIELD_NAMES>::NamedBitSet(const std::initializer_list<const std::string_view> &list) {
+        for (const auto &sv: list) (*this)[sv] = true;
+    }
+
+    template<const auto &FIELD_NAMES>
+    constexpr std::vector<std::string> NamedBitSet<FIELD_NAMES>::flag_name_strs() const {
+        const auto names = flag_names();
+        return { names.begin(), names.end() };
+    }
+
+    template<const auto &FIELD_NAMES>
+    constexpr std::vector<std::string_view> NamedBitSet<FIELD_NAMES>::flag_names() const {
+        std::vector<std::string_view> result;
+        for (const auto &[name, idx]: PAIRS) {
+            if (_bits[idx]) result.push_back(name);
+        }
+        return result;
+    }
+
+
+    template<const auto &FIELD_NAMES>
+    constexpr bool NamedBitSet<FIELD_NAMES>::operator[](const std::string_view &name) const {
+        return _bits[index_of(name)];
+    }
+
+    template<const auto &FIELD_NAMES>
+    constexpr NamedBitSet<FIELD_NAMES>::BitRef NamedBitSet<FIELD_NAMES>::operator[](const std::string_view &name) {
+        return _bits[index_of(name)];
+    }
+
+    template<const auto &FIELD_NAMES>
+    constexpr const NamedBitSet<FIELD_NAMES>::BitSet &NamedBitSet<FIELD_NAMES>::bits() const { return _bits; }
+
+    template<const auto &FIELD_NAMES>
+    constexpr std::size_t NamedBitSet<FIELD_NAMES>::index_of(const std::string_view &name) {
+        for (const auto &[field, idx]: PAIRS) {
+            if (field == name) return idx;
+        }
+        std::string errmsg = "Invalid field name "s + std::string(name.data()) + " in call to index_of";
+        throw std::invalid_argument(errmsg);
+    }
+}

data/ext/ruble/extconf.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# FIXME: This won't work because extensions aren't built from inside the gem dir when installed
+# ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile", __dir__)
+# require "bundler/setup" # Set up gems listed in the Gemfile.
+Bundler.require(:build)
+require_relative '../../lib/ruble/build'
+
+require 'mkmf-rice'
+# TODO(?): see what https://rubygems.org/gems/autobuild has to offer
+
+# noinspection RubyMismatchedArgumentType
+THIS_DIR = Pathname.new(__dir__)
+
+@generator = RuBLE::Build::Extconf.instance
+require 'debug' if @generator.debug_mode?
+
+@generator.write_build_config(path: THIS_DIR / 'build-config.cmake')
+
+# TODO: need to confirm the values (for install dir, compile args, etc) outputted in Makefile
+#   are the same values CMake gets from parsing 'build-config.json'
+# TODO: confirm dummy_makefile isn't missing any needed fields
+#   currently, I don't see where the build dir is set
+
+create_makefile 'ruble'
+File.open(THIS_DIR / 'Makefile', 'at') do |f|
+  #f.puts 'include cmake.mk'
+end
+
+# TODO: does setting TARGET_ENTRY in makefile do anything? (if so, use it)

data/ext/ruble/management/Registry.cpp

@@ -0,0 +1,63 @@
+#include "types/declarations.hpp"
+#include "bindings/Adapter.hpp"
+#include "bindings/Peripheral.hpp"
+#include "management/Registry.hpp"
+#include "management/RegistryFactory.hpp"
+#include "bindings/Service.hpp"
+#include "bindings/Characteristic.hpp"
+
+namespace RuBLE {
+
+    void Init_Registries() {
+        rb_cAdapterRegistry = define_class_under<AdapterRegistry>(rb_mRuBLE, "AdapterRegistry")
+                .define_method("size", &AdapterRegistry::size)
+                .define_method("to_s", &AdapterRegistry::to_s);
+        define_map_under<AdapterRegistry::Collection>(rb_cAdapterRegistry, "Map");
+
+        if (!adapterRegistryFactory) adapterRegistryFactory = AdapterRegistryFactory::instance();
+        if (!adapterRegistry) adapterRegistry = adapterRegistryFactory->registry();
+        rb_cAdapterRegistry.define_singleton_attr("registry", &*adapterRegistry, Rice::AttrAccess::Read);
+        rb_cAdapterRegistry.iv_set("@registry", *adapterRegistry->_registry);
+
+        rb_cPeripheralRegistry = define_class_under<PeripheralRegistry>(rb_mRuBLE, "PeripheralRegistry")
+                .define_method("to_s", &PeripheralRegistry::to_s)
+                .define_method("size", &PeripheralRegistry::size);
+
+        rb_cAdapter
+                .define_attr("peripheral_registry", &Adapter::_peripheral_registry, Rice::AttrAccess::Read);
+
+        if (!peripheralRegistryFactory) peripheralRegistryFactory = PeripheralRegistryFactory::instance();
+
+        rb_cServiceRegistry = define_class_under<ServiceRegistry>(rb_mRuBLE, "ServiceRegistry")
+                .define_method("to_s", &ServiceRegistry::to_s)
+                .define_method("size", &ServiceRegistry::size);
+
+        define_map_under<Peripheral::ServiceMap>(rb_cPeripheral, "ServiceMap");
+        rb_cPeripheral
+            .define_method("services", &Peripheral::services)
+            .define_method("[]", &Peripheral::operator[])
+            .define_attr("service_registry", &Peripheral::_service_registry, Rice::AttrAccess::Read)
+        ;
+        if (!serviceRegistryFactory) serviceRegistryFactory = ServiceRegistryFactory::instance();
+
+        rb_cCharacteristicRegistry = define_class_under<CharacteristicRegistry>(rb_mRuBLE, "CharacteristicRegistry")
+                .define_method("to_s", &ServiceRegistry::to_s)
+                .define_method("size", &ServiceRegistry::size);
+
+        define_map_under<CharacteristicRegistry::Collection>(rb_cService, "CharacteristicMap");
+        rb_cService
+                .define_method("characteristics", &Service::characteristics)
+                .define_method("[]", &Service::operator[])
+                .define_attr("characteristic_registry", &Service::_characteristic_registry, Rice::AttrAccess::Read);
+
+        if (!characteristicRegistryFactory) characteristicRegistryFactory = CharacteristicRegistryFactory ::instance();
+        define_map_under<Characteristic::DescriptorMap>(rb_cCharacteristic, "DescriptorMap");
+        rb_cCharacteristic
+                .define_method("descriptors", &Characteristic::descriptors)
+                .define_method("[]", &Characteristic::operator[])
+                .define_attr("descriptors", &Characteristic::_descriptors, Rice::AttrAccess::Read);
+
+    }
+
+}
+