ruble 0.0.3.alpha

data/ext/ruble/types/ruby.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <rice/rice.hpp>
+#include <ruby/ruby.h>
+#include <thread>
+#include <type_traits>
+
+namespace RuBLE {
+    namespace Rice = ::Rice;
+    using ::Rice::Object, ::Rice::Data_Object, ::Rice::Data_Type, ::Rice::Arg;
+
+    using RubyThreadId = VALUE;
+    using CppThreadId = std::thread::id;
+
+    template <typename T = void>
+    using RbThreadCreateFn = VALUE(*)(T*);
+    template <typename Ret = void, typename T = void>
+    using RbThreadCallFn [[maybe_unused]] = Ret *(*)(T*);
+    template <typename T = void>
+    using RbUbfFn [[maybe_unused]] = void (*)(T*);
+
+
+    template <class T>
+    using ToRubyObjectResult = std::invoke_result_t<decltype(&T::self), const T&>;
+
+    template <class T>
+    concept ReturnsRubyValue = std::is_convertible_v<std::invoke_result_t<decltype(&T::value), const T&>, VALUE>;
+    template <class T>
+    concept RiceObject = std::derived_from<Rice::Object, T> && ReturnsRubyValue<T>;
+    template <class T>
+    concept RubyValue = RiceObject<T> || std::same_as<VALUE, T>;
+
+
+    template<typename T>
+    concept HasRubyObject = RubyValue<ToRubyObjectResult<T>> && requires { typename T::DataObject; };
+}

data/ext/ruble/types/stl.hpp

@@ -0,0 +1,41 @@
+#pragma once
+#include <chrono>
+#include <optional>
+#include <ranges>
+#include <semaphore>
+#include <type_traits>
+
+namespace chrono = std::chrono;
+namespace views = std::views;
+namespace ranges = std::ranges;
+
+namespace RuBLE {
+    const constexpr auto semaphore_max = std::numeric_limits<uint16_t>::max();
+    using Semaphore [[maybe_unused]] = std::counting_semaphore<semaphore_max>;
+
+    template<typename T>
+    struct is_duration {
+        constexpr static const bool value = false;
+    };
+
+    template<typename ...Types>
+    struct is_duration<std::chrono::duration<Types...>> {
+        constexpr static const bool value = true;
+    };
+    template<typename T>
+    concept Duration = is_duration<T>::value;
+
+    template<class T>
+    concept OptionalDuration = Duration<T> || std::same_as<std::nullopt_t, T>;
+
+    template<class T, class R>
+    concept RangeOf = requires(const R &r, T &t) {
+        { *ranges::begin(r) } -> std::convertible_to<T>;
+        { *ranges::end(r) } -> std::convertible_to<T>;
+    };
+
+    template<ranges::viewable_range RangeT>
+    using RangeIteratorType = std::invoke_result_t<decltype(std::ranges::begin), RangeT &&>;
+    template<ranges::viewable_range RangeT>
+    using RangeElementType [[maybe_unused]] = std::invoke_result_t<decltype(RangeIteratorType<RangeT>::operator*), RangeIteratorType<RangeT> &&>;
+}

data/ext/ruble/utils/RubyCallbackTraits.cpp

@@ -0,0 +1,28 @@
+#include "RubyCallbackTraits.hpp"
+#include "types/ruby.hpp"
+
+namespace RuBLE::Utils::Ruby {
+    CallbackTraits::CallbackTraits(const VALUE &val) {
+        if (RB_NIL_OR_UNDEF_P(val) || rb_obj_is_proc(val) != Qtrue)
+            throw std::invalid_argument("Argument must be a proc or lambda");
+
+        for (const auto &key: Ruby::FnParameterTypes) _map[key] = 0;
+        Rice::Array params = Object(val).call("parameters");
+        for (auto el: params) {
+            Rice::Array array = el.value();
+            std::string type = rb_id2name(rb_sym2id(array[0].value()));
+            ++_map[type];
+        }
+        _is_lambda = rb_proc_lambda_p(val) == Qtrue;
+    }
+
+    void CallbackTraits::assert_accepts_n_args(const VALUE &val, const uint8_t &n, bool allow_nil) {
+        if (RB_NIL_OR_UNDEF_P(val)) {
+            if (allow_nil) return;
+            throw std::invalid_argument("Argument must be a proc or lambda (nil values not accepted)");
+        }
+        if (CallbackTraits(val).accepts_n_args(n)) return;
+        throw std::invalid_argument("Argument must be callable with exactly "s +
+                                    std::to_string(n) + " positional arguments.");
+    }
+}

data/ext/ruble/utils/RubyCallbackTraits.hpp

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <ruby/ruby.h>
+#include <unordered_set>
+#include <unordered_map>
+#include <string>
+
+// Used to confirm callbacks accept the number of arguments needed for callbacks
+// This is preferable to alerting when callbacks are invoked, where it would be
+// hard to decipher what's wrong from the ArgumentError
+// unfortunately, Proc#arity isn't sufficiently informative because it doesn't
+// take into account required kw args.
+namespace RuBLE::Utils::Ruby {
+    static constexpr std::initializer_list<std::string_view> FnParameterTypes {
+        "req", "opt", "rest", "keyreq", "key", "keyrest"
+    };
+
+    class CallbackTraits {
+        bool _is_lambda = false;
+        std::unordered_map<std::string_view, uint_least8_t> _map;
+    public:
+        using MapValueType = decltype(_map)::mapped_type;
+
+        CallbackTraits(const VALUE &val);
+
+        [[maybe_unused]] constexpr bool is_lambda() const { return _is_lambda; }
+
+        [[maybe_unused]] constexpr bool is_proc() const { return !_is_lambda; }
+        constexpr const MapValueType &operator[](const std::string &type) const {
+            return _map.at(type);
+        }
+
+        // whether the lambda would accept exactly N positional args
+        constexpr bool accepts_n_args(int n) const {
+            if (!_is_lambda) return true;
+            if (_map.at("keyreq") > 0) return false; // if any keyword arguments are required
+            MapValueType min = _map.at("req");
+            MapValueType max = _map.at("rest") > 0 ? std::numeric_limits<MapValueType>::max() : min + _map.at("opt");
+            return min <= n && n <= max;
+        }
+
+        // throws an exception if the argument can't be called with exactly N positional args
+        static void assert_accepts_n_args(const VALUE &val, const uint8_t &n, bool allow_nil = true);
+    };
+}
+namespace RuBLE {
+    namespace Ruby = Utils::Ruby;
+}

data/ext/ruble/utils/async.cpp

@@ -0,0 +1,10 @@
+#include "async.hpp"
+
+namespace RuBLE::Utils::Async {
+    void thread_sleep() {
+        rb_thread_schedule();
+        // TODO: maybe multiply sleep time by getloadavg() on linux (from cstdlib)
+        std::this_thread::sleep_for(250ms);
+        std::this_thread::yield();
+    }
+}

data/ext/ruble/utils/async.hpp

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <functional>
+#include <ruby/ruby.h>
+#include <thread>
+#include "types/helpers.hpp"
+#include "types/stl.hpp"
+
+namespace RuBLE::Utils {
+    namespace Async {
+        using namespace std::chrono_literals;
+        // Not sure exactly which of these is doing the trick, but calling this when waiting
+        // on an async operation tends to get ruby jump to its other threads
+        // oddly, none of these commands, by themselves, were working for me
+        void thread_sleep();
+
+        template <OptionalDuration DurationT = std::nullopt_t>
+        bool wait_until(const std::function<bool(void)> &fn, const DurationT &duration = std::nullopt) {
+            using PredicateFn = std::function<bool()>;
+            constexpr const bool has_timeout = !is_nullopt<DurationT>;
+
+            bool fn_result = false, timed_out = false;
+            PredicateFn is_timed_out;
+
+            if constexpr (has_timeout) {
+                using clock = chrono::high_resolution_clock;
+                using time_point = clock::time_point;
+                time_point start = clock::now();
+                time_point until = start + chrono::duration_cast<clock::duration>(duration);
+
+                is_timed_out = [&timed_out, until] () -> bool {
+                    return until < clock::now();
+                };
+            } else {
+                is_timed_out = [] { return false; };
+            }
+
+            auto check_if_done = [&is_timed_out, &timed_out, &fn, &fn_result] () -> bool {
+                fn_result = fn();
+                timed_out = is_timed_out();
+                return fn_result || timed_out;
+            };
+
+            while(!check_if_done()) thread_sleep();
+            return fn_result;
+        }
+
+
+//        template <typename From>
+//        using WrapReferences = std::conditional_t<std::is_reference_v<From>, std::reference_wrapper<std::remove_reference_t<From>>, From>;
+//
+//        template <Future FutureT, typename ...Args> // T should be std::shared_future<T> or std::future<T>
+//        bool wait_for_future(FutureT future, const Args&... args) {
+//            using PredicateFn = std::function<bool()>;
+//            PredicateFn is_ready = [&future] { return future.wait_for(0s) == std::future_status::ready; };
+//            return wait_until(is_ready, args...);
+//        }
+//
+//        template <Future FutureT>
+//        using await_future_result = typename future_traits<FutureT>::value_type;
+//
+//        template <Future FutureT, typename ...Args> requires (sizeof...(Args) == 1)
+//        std::optional<WrapReferences<await_future_result<FutureT>>> await_future(FutureT future, const Args& ...args) {
+//            using ResultType = WrapReferences<await_future_result<FutureT>>;
+//            bool done = wait_for_future(future, args...);
+//            return done ? std::ref(future.get()) : std::optional<ResultType>();
+//        }
+//
+//        template <Future FutureT>
+//        await_future_result<FutureT> await_future(FutureT future) {
+//            await_future(future, std::nullopt);
+//            return future.get();
+//        }
+    }
+    using namespace Async;
+}

data/ext/ruble/utils/containers.hpp

@@ -0,0 +1,41 @@
+#pragma once
+#include <ranges>
+#include <functional>
+#include <map>
+#include <numeric>
+
+namespace views = std::views;
+namespace ranges = std::ranges;
+
+namespace RuBLE::Utils {
+    namespace Containers {
+        constexpr std::string join(const ranges::viewable_range auto &range, const std::string_view &sep) {
+            if (ranges::empty(range)) return "";
+            if (ranges::size(range) == 1) return std::string(*ranges::cbegin(range));
+            const auto fold = [&sep](const std::string_view &a, const std::string_view &b) {
+                return std::string(a) + std::string(sep) + std::string(b);
+            };
+            return std::accumulate(std::next(ranges::cbegin(range)), ranges::cend(range),
+                                   std::string(*ranges::cbegin(range)), fold);
+        }
+
+        template<class KeyT, class ValueT,
+                class FnT = std::function<std::remove_reference_t<KeyT>(const std::remove_cvref_t<ValueT> &)>,
+                class ResultT = std::map<std::remove_reference_t<KeyT>, std::remove_reference_t<ValueT>>,
+                ranges::viewable_range RangeT> requires requires(FnT &&fnT, RangeT &&rangeT) {
+                    { fnT(**ranges::begin(rangeT)) } -> std::convertible_to<std::remove_reference_t<KeyT>>;
+                }
+        [[maybe_unused]] ResultT map_by(RangeT &&r, FnT &&mapFn) {
+            auto makePair = [&mapFn](ValueT &val) -> auto {
+                KeyT key = mapFn(*val);
+                return std::make_pair(std::move(key), val);
+            };
+            auto pairView = views::transform(r, makePair);
+            return {pairView.begin(), pairView.end()};
+        }
+
+    } // Containers
+    using namespace Containers;
+} // RuBLE::Utils
+
+

data/ext/ruble/utils/exception_handling.cpp

@@ -0,0 +1,50 @@
+#include "exception_handling.hpp"
+
+namespace RuBLE::ExceptionHandling {
+    std::terminate_handler _old_terminate_handler = nullptr;
+
+
+
+    void wrap_termination_handler() {
+        if (_old_terminate_handler != nullptr) {
+            throw std::runtime_error("Old terminate exception already set. Would overflow.");
+        }
+        _old_terminate_handler = std::get_terminate();
+
+        std::set_terminate([] {
+            std::exception_ptr ex = std::current_exception();
+
+//            std::cerr << "terminate called after throwing an instance of '";
+//            std::cerr << Utils::human_type_name(ex) << "'" << std::endl;
+//            std::cerr << "what():  " << ex
+            try {
+                std::cerr << "C++ Backtrace: " << std::endl;
+                std::cerr << boost::stacktrace::stacktrace() << std::endl;
+            } catch (const std::exception &ex2) {
+                std::throw_with_nested(ex); // TODO: test that this does what I think it does
+            }
+            try {
+                std::cerr << "Ruby Backtrace: " << std::endl;
+                rb_backtrace();
+                std::cerr << std::endl << std::endl;
+            } catch (const std::exception &ex2) {
+                std::throw_with_nested(ex);
+            }
+
+            if (_old_terminate_handler != nullptr) _old_terminate_handler();
+            // TODO: consider using boost::core::verbose_terminate_handler somewhere
+        });
+    }
+
+    [[maybe_unused]] void abort_with_stack() {
+        try {
+            std::cerr << boost::stacktrace::stacktrace();
+        } catch (const std::exception &ex2) {
+            std::cerr << "Could not generate C++ stacktrace. Skipping." << std::endl;
+        }
+        std::abort();
+    }
+
+    void throw_exception() { throw std::runtime_error("test error"); }
+}
+

data/ext/ruble/utils/exception_handling.hpp

@@ -0,0 +1,53 @@
+#pragma once
+
+#include "config.h"
+#include <backtrace.h>
+#include <boost/stacktrace.hpp>
+#include <boost/exception/all.hpp>
+#include <iostream>     // std::cerr
+#include <exception>    // std::set_terminate
+#include <ruby/ruby.h>
+
+namespace boost {
+    inline void assertion_failed_msg(const char *expr, const char *msg, const char *function, const char *, long) {
+        std::cerr << "Expression '" << expr << "' is false in function '" << function << "': " << (msg ? msg : "<...>")
+                  << ".\nBacktrace:\n" << boost::stacktrace::stacktrace() << '\n';
+
+        std::abort();
+    }
+
+    [[maybe_unused]] inline void assertion_failed(const char *expr, const char *function, const char *file, long line) {
+        ::boost::assertion_failed_msg(expr, nullptr, function, file, line);
+    }
+} // namespace boost
+
+namespace RuBLE::ExceptionHandling {
+    [[noreturn]] void throw_exception();
+    [[maybe_unused]] void abort_with_stack();
+
+    using traced = boost::error_info<struct tag_stacktrace, boost::stacktrace::stacktrace>;
+
+    template <typename T>
+    [[maybe_unused]] boost::stacktrace::stacktrace extract_stacktrace(const T &e) {
+        boost::stacktrace::stacktrace *st = boost::get_error_info<traced>(e);
+        // TODO: does this method work / is it memory-safe
+        boost::stacktrace::stacktrace &st2(*st);
+        return st2;
+    }
+
+    template<class E>
+    constexpr auto add_backtrace(const E &e) {
+        return boost::enable_error_info(e) << traced(boost::stacktrace::stacktrace());
+    }
+
+    // TODO: see if we can somehow add C++ backtrace data to ruby exceptions
+    template<class E>
+    constexpr void throw_with_backtrace(const E &e) {
+        throw add_backtrace(e);
+    }
+
+    void wrap_termination_handler();
+    extern std::terminate_handler _old_terminate_handler;
+}
+
+

data/ext/ruble/utils/garbage_collection.cpp

@@ -0,0 +1,82 @@
+#include "garbage_collection.hpp"
+
+#include "management/Registry.hpp"
+#include "management/RegistryFactory.hpp"
+#include "bindings/Adapter.hpp"
+#include "bindings/Peripheral.hpp"
+#include "bindings/Service.hpp"
+#include "bindings/Characteristic.hpp"
+#include "containers/ByteArray.hpp"
+
+namespace Rice {
+    template<>
+    void ruby_mark<RuBLE::AdapterRegistryFactory>(RuBLE::AdapterRegistryFactory *registryFactory) {
+        registryFactory->ruby_mark();
+    }
+
+    template<>
+    void ruby_mark<RuBLE::ByteArray>(RuBLE::ByteArray *byteArray) {
+        byteArray->ruby_mark();
+    }
+
+    template<>
+    void ruby_mark<RuBLE::PeripheralRegistryFactory>(RuBLE::PeripheralRegistryFactory *registryFactory) {
+        registryFactory->ruby_mark();
+    }
+
+    template<>
+    void ruby_mark<RuBLE::ServiceRegistryFactory>(RuBLE::ServiceRegistryFactory *registryFactory) {
+        registryFactory->ruby_mark();
+    }
+
+    template<>
+    void ruby_mark<RuBLE::CharacteristicRegistryFactory>(RuBLE::CharacteristicRegistryFactory *registryFactory) {
+        registryFactory->ruby_mark();
+    }
+
+    template<>
+    void ruby_mark<RuBLE::AdapterRegistry>(RuBLE::AdapterRegistry *registry) {
+        registry->ruby_mark();
+    }
+
+    template<>
+    void ruby_mark<RuBLE::PeripheralRegistry>(RuBLE::PeripheralRegistry *registry) { registry->ruby_mark(); }
+
+    template<>
+    void ruby_mark<RuBLE::ServiceRegistry>(RuBLE::ServiceRegistry *registry) { registry->ruby_mark(); }
+
+    template<>
+    void ruby_mark<RuBLE::CharacteristicRegistry>(RuBLE::CharacteristicRegistry *registry) { registry->ruby_mark(); }
+
+    template<>
+    void ruby_mark<RuBLE::Service>(RuBLE::Service *service) { service->ruby_mark(); }
+
+    template<>
+    void ruby_mark<RuBLE::Adapter>(RuBLE::Adapter *adapter) { adapter->ruby_mark(); }
+
+
+    template<>
+    void ruby_mark<RuBLE::Characteristic>(RuBLE::Characteristic *characteristic) { characteristic->ruby_mark(); }
+
+    template<>
+    void ruby_mark<RuBLE::Peripheral>(RuBLE::Peripheral *peripheral) { peripheral->ruby_mark(); }
+}
+
+// TODO: do these change anything? Without these,
+//  CLion seemed to be suggesting that many of the functions above were unused,
+//  which would tend to cause hard-to-detect errors, so just to be safe,
+//  assert that these templated versions of Rice::ruby_mark exist.
+static_assert(&Rice::ruby_mark<RuBLE::Callback>);
+static_assert(&Rice::ruby_mark<RuBLE::Adapter>);
+static_assert(&Rice::ruby_mark<RuBLE::AdapterRegistry>);
+static_assert(&Rice::ruby_mark<RuBLE::AdapterRegistryFactory>);
+static_assert(&Rice::ruby_mark<RuBLE::Peripheral>);
+static_assert(&Rice::ruby_mark<RuBLE::PeripheralRegistry>);
+static_assert(&Rice::ruby_mark<RuBLE::PeripheralRegistryFactory>);
+static_assert(&Rice::ruby_mark<RuBLE::Service>);
+static_assert(&Rice::ruby_mark<RuBLE::ServiceRegistry>);
+static_assert(&Rice::ruby_mark<RuBLE::ServiceRegistryFactory>);
+static_assert(&Rice::ruby_mark<RuBLE::Characteristic>);
+static_assert(&Rice::ruby_mark<RuBLE::CharacteristicRegistry>);
+static_assert(&Rice::ruby_mark<RuBLE::CharacteristicRegistryFactory>);
+

data/ext/ruble/utils/garbage_collection.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "types/declarations.hpp"
+#include "types/ruby.hpp"
+
+namespace Rice {
+    template<> constexpr void ruby_mark<RuBLE::Callback>(RuBLE::Callback*);
+    template<> void ruby_mark<RuBLE::Adapter>(RuBLE::Adapter *);
+    template<> void ruby_mark<RuBLE::AdapterRegistry>(RuBLE::AdapterRegistry*);
+    template<> void ruby_mark<RuBLE::AdapterRegistryFactory>(RuBLE::AdapterRegistryFactory*);
+    template<> void ruby_mark<RuBLE::ByteArray>(RuBLE::ByteArray*);
+    template<> void ruby_mark<RuBLE::Peripheral>(RuBLE::Peripheral*);
+    template<> void ruby_mark<RuBLE::PeripheralRegistry>(RuBLE::PeripheralRegistry*);
+    template<> void ruby_mark<RuBLE::PeripheralRegistryFactory>(RuBLE::PeripheralRegistryFactory*);
+    template<> void ruby_mark<RuBLE::Service>(RuBLE::Service*);
+    template<> void ruby_mark<RuBLE::ServiceRegistry>(RuBLE::ServiceRegistry*);
+    template<> void ruby_mark<RuBLE::ServiceRegistryFactory>(RuBLE::ServiceRegistryFactory*);
+    template<> void ruby_mark<RuBLE::Characteristic>(RuBLE::Characteristic*);
+    template<> void ruby_mark<RuBLE::CharacteristicRegistry>(RuBLE::CharacteristicRegistry*);
+    template<> void ruby_mark<RuBLE::CharacteristicRegistryFactory>(RuBLE::CharacteristicRegistryFactory*);
+}
+

data/ext/ruble/utils/hash.cpp

@@ -0,0 +1,83 @@
+#include "hash.hpp"
+#include "bindings/Adapter.hpp"
+#include "bindings/Characteristic.hpp"
+#include "bindings/Peripheral.hpp"
+
+std::size_t std::hash<SimpleBLE::Adapter>::operator()(const SimpleBLE::Adapter &a) const noexcept {
+    SimpleBLE::BluetoothAddress addr = const_cast<SimpleBLE::Adapter &>(a).address();
+    std::size_t h1 = typeid(a).hash_code();
+    static auto hasher = std::hash<SimpleBLE::BluetoothAddress>{};
+    return h1 ^ (hasher(addr) << 1);
+}
+
+std::size_t std::hash<RuBLE::Adapter>::operator()(const RuBLE::Adapter &a) const noexcept {
+    std::size_t h1 = typeid(a).hash_code();
+    static auto hasher = std::hash<SimpleBLE::Adapter>{};
+    return h1 ^ (hasher(a.get()) << 1);
+}
+
+std::size_t std::hash<SimpleBLE::Characteristic>::operator()(const SimpleBLE::Characteristic &p) const noexcept {
+    auto uuid = const_cast<SimpleBLE::Characteristic &>(p).uuid();
+    std::size_t h1 = typeid(p).hash_code();
+    static auto hasher = std::hash<decltype(uuid)>{};
+    return h1 ^ (hasher(uuid) << 1);
+}
+
+std::size_t std::hash<RuBLE::Characteristic>::operator()(const RuBLE::Characteristic &p) const noexcept {
+    std::size_t h1 = typeid(p).hash_code();
+    static auto hasher = std::hash<SimpleBLE::Characteristic>{};
+    return h1 ^ (hasher(p.get()) << 1);
+}
+
+std::size_t std::hash<RuBLE::Descriptor>::operator()(const RuBLE::Descriptor& d) const noexcept {
+    std::size_t h1 = typeid(d).hash_code();
+    static auto hasher = std::hash<std::remove_cvref_t<decltype(d.uuid())>>{};
+    return h1 ^ (hasher(d.uuid()) << 1);
+}
+
+
+std::size_t std::hash<SimpleBLE::Service>::operator()(const SimpleBLE::Service &p) const noexcept {
+    auto uuid = const_cast<SimpleBLE::Service &>(p).uuid();
+    std::size_t h1 = typeid(p).hash_code();
+    static auto hasher = std::hash<decltype(uuid)>{};
+    return h1 ^ (hasher(uuid) << 1);
+}
+
+std::size_t std::hash<RuBLE::Service>::operator()(const RuBLE::Service &p) const noexcept {
+    std::size_t h1 = typeid(p).hash_code();
+    static auto hasher = std::hash<SimpleBLE::Service>{};
+    return h1 ^ (hasher(p.get()) << 1);
+}
+
+size_t std::hash<SimpleBLE::Peripheral>::operator()(const SimpleBLE::Peripheral &p) const noexcept {
+    SimpleBLE::BluetoothAddress addr = const_cast<SimpleBLE::Peripheral &>(p).address();
+    std::size_t h1 = typeid(p).hash_code();
+    static auto hasher = std::hash<SimpleBLE::BluetoothAddress>{};
+    return h1 ^ (hasher(addr) << 1);
+}
+
+std::size_t std::hash<RuBLE::Peripheral>::operator()(const RuBLE::Peripheral &p) const noexcept {
+    std::size_t h1 = typeid(p).hash_code();
+    static auto hasher = std::hash<SimpleBLE::Peripheral>{};
+    return h1 ^ (hasher(p.get()) << 1);
+}
+
+template<> struct std::hash<SimpleBLE::Adapter>;
+template<> struct std::hash<RuBLE::Adapter>;
+template<> struct std::hash<SimpleBLE::Peripheral>;
+template<> struct std::hash<RuBLE::Peripheral>;
+template<> struct std::hash<SimpleBLE::Service>;
+template<> struct std::hash<RuBLE::Service>;
+template<> struct std::hash<SimpleBLE::Characteristic>;
+template<> struct std::hash<RuBLE::Characteristic>;
+template<> struct std::hash<RuBLE::Descriptor>;
+// TODO: Use this in the registry map, but don't put in std::hash
+//template<typename Key, class ProxyClass, class Value>
+//struct std::hash<RuBLE::Registry<Key, ProxyClass, Value>> {
+//    std::size_t operator()(const RuBLE::Registry<Key, ProxyClass, Value>& r) const noexcept {
+//        std::size_t h1 = typeid(r).hash_code();
+//        using RegistryOwner = RuBLE::Registry<Key, ProxyClass, Value>::Owner;
+//        static auto hasher = std::hash<SimpleBLE::BluetoothAddress>{};
+//        return h1 ^ (hasher(r._registry) << 1);
+//    }
+//};

data/ext/ruble/utils/hash.hpp

@@ -0,0 +1,52 @@
+#pragma once
+#include <utility>
+#include "types/declarations.hpp"
+
+namespace RuBLE {
+    template<typename Key>
+    using HasherType = std::hash<Key>;
+
+    template<typename Key>
+    using HashFnType [[maybe_unused]] = std::invoke_result_t<std::hash<Key>()>;
+
+    template<typename Key>
+    using HashResultType = std::invoke_result<HashFnType<Key>, const Key &>::type;
+    static_assert(std::is_same<std::size_t, HashResultType<std::string>>::value);
+}
+
+template<> struct std::hash<SimpleBLE::Adapter> {
+    std::size_t operator()(const SimpleBLE::Adapter& a) const noexcept;
+};
+
+template<> struct std::hash<RuBLE::Adapter> {
+    std::size_t operator()(const RuBLE::Adapter& a) const noexcept;
+};
+
+template<> struct std::hash<SimpleBLE::Peripheral> {
+    std::size_t operator()(const SimpleBLE::Peripheral& p) const noexcept;
+};
+
+template<> struct std::hash<RuBLE::Peripheral> {
+    std::size_t operator()(const RuBLE::Peripheral& p) const noexcept;
+};
+
+template<> struct std::hash<SimpleBLE::Service> {
+    std::size_t operator()(const SimpleBLE::Service& s) const noexcept;
+};
+
+template<> struct std::hash<RuBLE::Service> {
+    std::size_t operator()(const RuBLE::Service& s) const noexcept;
+};
+
+template<> struct std::hash<SimpleBLE::Characteristic> {
+    std::size_t operator()(const SimpleBLE::Characteristic& s) const noexcept;
+};
+
+template<> struct std::hash<RuBLE::Characteristic> {
+    std::size_t operator()(const RuBLE::Characteristic& s) const noexcept;
+};
+
+template<> struct std::hash<RuBLE::Descriptor> {
+    std::size_t operator()(const RuBLE::Descriptor& s) const noexcept;
+};
+