ruble 0.0.3.alpha

data/ext/ruble/RuBLEHelpers.cmake

@@ -0,0 +1,240 @@
+# From https://stackoverflow.com/a/51987470
+# Get all properties that cmake supports
+execute_process(COMMAND cmake --help-property-list OUTPUT_VARIABLE CMAKE_PROPERTY_LIST)
+
+# Convert command output into a CMake list
+STRING(REGEX REPLACE ";" "\\\\;" CMAKE_PROPERTY_LIST "${CMAKE_PROPERTY_LIST}")
+STRING(REGEX REPLACE "\n" ";" CMAKE_PROPERTY_LIST "${CMAKE_PROPERTY_LIST}")
+# Fix https://stackoverflow.com/questions/32197663/how-can-i-remove-the-the-location-property-may-not-be-read-from-target-error-i
+list(FILTER CMAKE_PROPERTY_LIST EXCLUDE REGEX "^LOCATION$|^LOCATION_|_LOCATION$")
+# For some reason, "TYPE" shows up twice - others might too?
+list(REMOVE_DUPLICATES CMAKE_PROPERTY_LIST)
+
+# build whitelist by filtering down from CMAKE_PROPERTY_LIST in case cmake is
+# a different version, and one of our hardcoded whitelisted properties
+# doesn't exist!
+unset(CMAKE_WHITELISTED_PROPERTY_LIST)
+foreach(prop ${CMAKE_PROPERTY_LIST})
+    if(prop MATCHES "^(INTERFACE|[_a-z]|IMPORTED_LIBNAME_|MAP_IMPORTED_CONFIG_)|^(COMPATIBLE_INTERFACE_(BOOL|NUMBER_MAX|NUMBER_MIN|STRING)|EXPORT_NAME|IMPORTED(_GLOBAL|_CONFIGURATIONS|_LIBNAME)?|NAME|TYPE|NO_SYSTEM_FROM_IMPORTED)$")
+        list(APPEND CMAKE_WHITELISTED_PROPERTY_LIST ${prop})
+    endif()
+endforeach(prop)
+
+function(print_properties)
+    message ("CMAKE_PROPERTY_LIST = ${CMAKE_PROPERTY_LIST}")
+endfunction(print_properties)
+
+function(print_whitelisted_properties)
+    message ("CMAKE_WHITELISTED_PROPERTY_LIST = ${CMAKE_WHITELISTED_PROPERTY_LIST}")
+endfunction(print_whitelisted_properties)
+
+function(print_target_properties tgt)
+    if(NOT TARGET ${tgt})
+        message("There is no target named '${tgt}'")
+        return()
+    endif()
+
+    get_target_property(target_type ${tgt} TYPE)
+    if(target_type STREQUAL "INTERFACE_LIBRARY")
+        set(PROP_LIST ${CMAKE_WHITELISTED_PROPERTY_LIST})
+    else()
+        set(PROP_LIST ${CMAKE_PROPERTY_LIST})
+    endif()
+
+    foreach (prop ${PROP_LIST})
+        string(REPLACE "<CONFIG>" "${CMAKE_BUILD_TYPE}" prop ${prop})
+        # message ("Checking ${prop}")
+        get_property(propval TARGET ${tgt} PROPERTY ${prop} SET)
+        if (propval)
+            get_target_property(propval ${tgt} ${prop})
+            message ("${tgt} ${prop} = ${propval}")
+        endif()
+    endforeach(prop)
+endfunction(print_target_properties)
+
+function(dump_variables)
+    get_cmake_property(_variableNames VARIABLES)
+    list (SORT _variableNames)
+    foreach (_variableName ${_variableNames})
+        message(STATUS "${_variableName}=${${_variableName}}")
+    endforeach()
+endfunction()
+
+macro(build_boost)
+    set(REPO "https://github.com/boostorg/boost")
+    set(TAG boost-1.83.0)
+    cmake_path(SET CACHE_LOCATION NORMALIZE "${CMAKE_SOURCE_DIR}/../../tmp/${TAG}")
+
+    set(ADDITIONAL_DEPENDENCIES core;stacktrace)
+    set(HEADER_ONLY_LIBS headers;describe)
+    set(LINKED_LIBS exception;endian;algorithm) # + detected stacktrace backend
+    set(STACKTRACE_BACKEND_PRIORITIES backtrace;addr2line;windgb_cached;windbg;basic;noop)
+
+    set(ALL_LIBS ${HEADER_ONLY_LIBS};${LINKED_LIBS})
+    set(BUILD_DEPS ${ALL_LIBS})
+    set(BOOST_INCLUDE_LIBRARIES ${ADDITIONAL_DEPENDENCIES};${BUILD_DEPS})
+
+    list(TRANSFORM HEADER_ONLY_LIBS PREPEND "Boost::"
+            OUTPUT_VARIABLE HEADER_ONLY_NAMESPACES)
+    list(TRANSFORM LINKED_LIBS PREPEND "Boost::"
+            OUTPUT_VARIABLE LINKED_NAMESPACES)
+    list(TRANSFORM BUILD_DEPS PREPEND "boost_"
+            OUTPUT_VARIABLE PREFIXED_BUILD_DEPS)
+#    dump_variables()
+#    message(FATAL_ERROR "quitting")
+
+    set(STACKTRACE_BACKEND_PRIORITIES backtrace;addr2line;windgb_cached;windbg;basic;noop)
+    list(TRANSFORM STACKTRACE_BACKEND_PRIORITIES
+            PREPEND "stacktrace_"
+            OUTPUT_VARIABLE STACKTRACE_BACKENDS)
+
+#    set(USES_TERMINAL_DOWNLOAD ON)
+#    set(USES_TERMINAL_UPDATE ON)
+#    set(LOG_DOWNLOAD ON)
+#    set(LOG_UPDATE ON)
+
+    set(BOOST_ENABLE_PYTHON OFF)
+    set(BUILD_SHARED_LIBS OFF)
+    set(Boost_DEBUG OFF)
+    set(Boost_VERBOSE OFF)
+    set(BUILD_TESTING OFF)
+
+    # TODO: add option to use local boost (in which case we can link dynamically)
+
+        include(FetchContent)
+#        cmake_policy(SET CMP0097 NEW)
+        FetchContent_Declare(
+            Boost
+            SOURCE_DIR "${CACHE_LOCATION}"
+            URL "${rb_boost_asset_browser_download_url}"
+#            GIT_REPOSITORY "${REPO}" # TODO: would an archive make more sense(?)
+#            GIT_TAG "${TAG}" # TODO: set this in build-config.cmake
+#            GIT_PROGRESS ON
+#            GIT_SHALLOW ON
+#            GIT_SUBMODULES ""
+#            GIT_SUBMODULES_RECURSE OFF
+#            GIT_REMOTE_UPDATE_STRATEGY REBASE
+#            UPDATE_COMMAND git submodule update --init --recursive --remote -f --depth 1 -j ${NPROC}
+            DOWNLOAD_EXTRACT_TIMESTAMP ON
+            USES_TERMINAL_DOWNLOAD ON
+            USES_TERMINAL_UPDATE ON
+            OVERRIDE_FIND_PACKAGE
+    )
+    FetchContent_MakeAvailable(Boost)
+#    dump_variables()
+
+    find_package(
+        Boost
+        REQUIRED
+            ${BOOST_INCLDUE_LIBRARIES}
+        OPTIONAL_COMPONENTS
+            ${STACKTRACE_BACKENDS}
+        PATHS "${CACHE_LOCATION}" "${CACHE_LOCATION}/tools/cmake"
+        EXCLUDE_FROM_ALL ON
+        NO_DEFAULT_PATH
+    )
+endmacro()
+
+# TODO: Should we fall back with this?
+function(setup_boost build_target)
+    build_boost()
+
+    target_link_libraries(${build_target} INTERFACE ${HEADER_ONLY_NAMESPACES}) #Boost::headers Boost::exception Boost::describe Boost::endian)
+    target_link_libraries(${build_target} PRIVATE ${LINKED_NAMESPACES})
+    add_dependencies(${build_target} ${PREFIXED_BUILD_DEPS})
+
+    foreach(possible_backend IN LISTS STACKTRACE_BACKEND_PRIORITIES)
+        string(TOUPPER "${possible_backend}" possible_backend_upper)
+
+        message(STATUS "Testing for stacktrace backend ${possible_backend}")
+        message(STATUS "BOOST_STACKTRACE_ENABLE_${possible_backend_upper}: ${BOOST_STACKTRACE_ENABLE_${possible_backend_upper}}")
+        message(STATUS "BOOST_STACKTRACE_HAS_${possible_backend_upper}: ${BOOST_STACKTRACE_HAS_${possible_backend_upper}}")
+        if(NOT BOOST_STACKTRACE_ENABLE_${possible_backend_upper} OR NOT BOOST_STACKTRACE_HAS_${possible_backend_upper})
+            continue()
+        endif()
+
+        string(REGEX MATCH "^windbg_" STACKTRACE_BACKEND_IS_WINDBG "${possible_backend}")
+        set(STACKTRACE_BACKEND "${possible_backend}")
+        set(STACKTRACE_BACKEND "${possible_backend}" PARENT_SCOPE)
+        set(BOOST_STACKTRACE_LINK ON)
+        set(BOOST_STACKTRACE_LINK ON PARENT_SCOPE)
+        set(BOOST_STACKTRACE_USE_${possible_backend_upper} ON PARENT_SCOPE)
+
+        target_link_libraries(${build_target} PRIVATE Boost::stacktrace_${STACKTRACE_BACKEND})
+        add_dependencies(${build_target} boost_stacktrace_${STACKTRACE_BACKEND})
+
+        target_link_libraries(${build_target} PRIVATE Boost::stacktrace_${possible_backend})
+        if(possible_backend STREQUAL "backtrace")
+            include(FindBacktrace)
+            if(Backtrace_LIBRARY)
+                target_link_libraries(${build_target} PRIVATE ${Backtrace_LIBRARY})
+            endif()
+
+            if(Backtrace_HEADER)
+                set(BACKTRACE_HEADER_PATH "${Backtrace_INCLUDE_DIR}/${Backtrace_HEADER}")
+                set(BOOST_STACKTRACE_BACKTRACE_INCLUDE_FILE "${BACKTRACE_HEADER_PATH}" PARENT_SCOPE)
+            endif ()
+#        elseif(possible_backend STREQUAL "addr2line")
+#            # This really only makes sense to use if this is being built on the computer it's used on
+#            set(BOOST_STACKTRACE_ADDR2LINE_LOCATION "${CMAKE_ADDR2LINE}")
+        elseif(WINDOWS AND STACKTRACE_BACKEND_IS_WINDBG) # TODO: untested
+            find_library(OLE32 ole32)
+            find_library(WINDBGENG dbgeng)
+            target_link_libraries(${build_target} PUBLIC ole32 dbgeng)
+        endif()
+        break()
+    endforeach()
+
+    if(NOT BOOST_STACKTRACE_LINK)
+#        dump_variables()
+        message(FATAL_ERROR "Could not find supported Boost::stacktrace backend")
+    endif()
+    message(STATUS "Boost::stacktrace backend: ${STACKTRACE_BACKEND}")
+
+    set(UNUSED_STACKTRACE_BACKENDS ${STACKTRACE_BACKEND_PRIORITIES})
+    list(REMOVE_ITEM UNUSED_STACKTRACE_BACKENDS "${STACKTRACE_BACKEND}")
+    message(VERBOSE "Disabling unused Boost::stacktrace backends: ${UNUSED_STACKTRACE_BACKENDS}")
+    foreach(unused_backend IN LISTS UNUSED_STACKTRACE_BACKENDS)
+        string(TOUPPER "${unused_backend}" unused_backend_upper)
+        if(NOT BOOST_STACKTRACE_ENABLE_${unused_backend_upper})
+            continue()
+        endif()
+
+        set_target_properties(boost_stacktrace_${unused_backend} PROPERTIES EXCLUDE_FROM_ALL ON)
+        set(BOOST_STACKTRACE_ENABLE_${unused_backend_upper} OFF)
+    endforeach()
+endfunction()
+
+# TODO: try changing these into functions
+function(setup_simpleble build_target)
+    include(FetchContent)
+    # TODO: would it be easier/better to use git and the commit hash
+    #   and build SimpleBLE from source? The main downside is more
+    #   dependencies. The upside is vastly simplifying configuring
+    #   simpleble_DIR, as well as choosing between shared/static linking.
+    FetchContent_Declare(
+            simpleble
+            URL "${rb_simpleble_asset_browser_download_url}"
+            DOWNLOAD_EXTRACT_TIMESTAMP ON
+#            OVERRIDE_FIND_PACKAGE
+    )
+    FetchContent_MakeAvailable(simpleble)
+    set(simpleble_DIR ${simpleble_SOURCE_DIR}/${rb_simpleble_archive_path})
+    find_package(simpleble REQUIRED CONFIG PATHS "${simpleble_DIR}" NO_DEFAULT_PATH)
+    target_link_libraries("${build_target}" PUBLIC simpleble::simpleble)
+    include("${simpleble_CONFIG}")
+    message(STATUS "SimpleBLE found in ${simpleble_DIR}")
+endfunction()
+
+
+macro(setup_ruby build_target)
+    #set(_Ruby_DEBUG_OUTPUT ON)
+    set(RUBY_FIND_VERSION 3.2)
+    find_package(Ruby 3.2 REQUIRED Ruby_FIND_VIRTUALENV)
+    target_link_libraries("${build_target}" PUBLIC ${Ruby_LIBRARIES})
+    target_include_directories("${build_target}" PUBLIC ${Ruby_INCLUDE_DIRS})
+    target_include_directories("${build_target}" PRIVATE ${RICE_INCLUDE_PATH})
+    set_target_properties("${build_target}" PROPERTIES INSTALL_RPATH_USE_LINK_PATH ON)
+    message(STATUS "libruby ${Ruby_VERSION} found at ${Ruby_LIBRARY}")
+    message(STATUS "Rice ${RICE_VERSION} found in ${RICE_INCLUDE_PATH}")
+endmacro()

data/ext/ruble/bindings/Adapter.cpp

@@ -0,0 +1,193 @@
+#include <ranges>
+
+#include "types/declarations.hpp"
+#include "bindings/Adapter.hpp"
+#include "bindings/Peripheral.hpp"
+#include "management/Registry.hpp"
+#include "management/RegistryFactory.hpp"
+#include "management/RubyQueue.hpp"
+#include "utils/containers.hpp"
+
+namespace RuBLE {
+    using Rice::String;
+    Adapter::Adapter(const SimpleBLE::Adapter &adapter) :
+            _adapter(std::make_shared<SimpleBLE::Adapter>(adapter)),
+            _addr(_adapter->address()),
+            _peripheral_registry(peripheralRegistryFactory->registry(this)),
+            _on_scan_start(std::make_shared<Callback>(1)),
+            _on_scan_stop(std::make_shared<Callback>(1)),
+            _on_scan_update(std::make_shared<Callback>(2)),
+            _on_scan_find(std::make_shared<Callback>(2)),
+            _self(Adapter_DO(*this)) {
+        get().set_callback_on_scan_start([this]() {
+            RubyQueue::FnType fn = [this]() -> void { _on_scan_start->fire(self()); };
+            if (_on_scan_start) rubyQueue->push(fn);
+        });
+
+        get().set_callback_on_scan_stop([this]() {
+            RubyQueue::FnType fn = [this]() -> void { _on_scan_stop->fire(self()); };
+            if (_on_scan_stop) rubyQueue->push(fn);
+        });
+
+        get().set_callback_on_scan_updated([this](const SimpleBLE::Peripheral &peripheral) {
+            RubyQueue::FnType fn = [this, peripheral]() -> void {
+                const std::shared_ptr<Peripheral> &wrapped = _peripheral_registry->fetch(peripheral);
+                _on_scan_update->fire(wrapped->self(), self());
+            };
+            if (_on_scan_update) rubyQueue->push(fn);
+        });
+
+        get().set_callback_on_scan_found([this](const SimpleBLE::Peripheral &peripheral) {
+            RubyQueue::FnType fn = [this, peripheral]() -> void {
+                const std::shared_ptr<Peripheral> &wrapped = _peripheral_registry->fetch(peripheral);
+                _on_scan_find->fire(wrapped->self(), self());
+            };
+            if (_on_scan_find) rubyQueue->push(fn);
+        });
+    }
+
+    bool Adapter::initialized() const { return get().initialized(); }
+
+    std::string Adapter::identifier() { return (_adapter) ? get().identifier() : ""; }
+
+
+    BluetoothAddress Adapter::address() const {
+        return _addr; /*get().address();*/
+    }
+
+    void Adapter::scan_start() { if (!scan_is_active()) get().scan_start(); }
+
+    void Adapter::scan_stop() { if (scan_is_active()) get().scan_stop(); }
+
+    void Adapter::scan_for(int timeout_ms) { get().scan_for(timeout_ms); }
+
+    bool Adapter::scan_is_active() const {
+        return const_cast<Adapter*>(this)->get().scan_is_active();
+    }
+
+    bool Adapter::operator==(const SimpleBLE::BluetoothAddress &addr) const { return !_addr.empty() && _addr == addr; }
+
+    bool Adapter::operator==(const Adapter &ap) const { return *this == ap._addr; }
+
+    std::vector<std::shared_ptr<Peripheral>> Adapter::scan_get_results() {
+        auto unwrappedPeripherals = get().scan_get_results();
+        return _peripheral_registry->map_to_objects(unwrappedPeripherals);
+    }
+
+    Rice::Array Adapter::scan_get_ruby_results() {
+        auto unwrappedPeripherals = get().scan_get_results();
+        return _peripheral_registry->map_to_ruby_objects(unwrappedPeripherals);
+    }
+
+    std::vector<std::shared_ptr<Peripheral>> Adapter::get_paired_peripherals() {
+        auto unwrappedPeripherals = get().get_paired_peripherals();
+        return _peripheral_registry->map_to_objects(unwrappedPeripherals);
+    }
+
+
+    Rice::Array Adapter::get_ruby_paired_peripherals() {
+        auto unwrappedPeripherals = get().get_paired_peripherals();
+        return _peripheral_registry->map_to_ruby_objects(unwrappedPeripherals);
+    }
+
+    SimpleBLE::Adapter &Adapter::get() {
+        if (!_adapter) throw std::runtime_error("Tried fetching address for unconfigured Adapter instance");
+        return *_adapter;
+    }
+
+    const SimpleBLE::Adapter &Adapter::get() const {
+        if (!_adapter) throw std::runtime_error("Tried fetching address for unconfigured Adapter instance");
+        return *_adapter;
+    }
+
+    Object Adapter::self() const { return _self; }
+
+    bool Adapter::bluetooth_enabled() { return SimpleBLE::Adapter::bluetooth_enabled(); }
+
+    std::vector<std::shared_ptr<Adapter>> Adapter::get_adapters() {
+        std::vector<SimpleBLE::Adapter> unwrappedAdapters = SimpleBLE::Adapter::get_adapters();
+        return adapterRegistry->map_to_objects(unwrappedAdapters);
+    }
+
+    Rice::Array Adapter::get_ruby_adapters() {
+        std::vector<SimpleBLE::Adapter> unwrappedAdapters = SimpleBLE::Adapter::get_adapters();
+        return adapterRegistry->map_to_ruby_objects(unwrappedAdapters);
+    }
+
+    void Adapter::on_scan_start(Object new_cb) { _on_scan_start->set(new_cb); }
+
+    void Adapter::on_scan_stop(Object new_cb) { _on_scan_stop->set(new_cb); }
+
+    void Adapter::on_scan_update(Object new_cb) { _on_scan_update->set(new_cb); }
+
+    void Adapter::on_scan_find(Object new_cb) { _on_scan_find->set(new_cb); }
+
+    std::unordered_set<std::string> Adapter::status_flags() const {
+        using PossibleFlagMap = std::unordered_map<std::string, std::function<bool(const Adapter&)>>;
+        static const PossibleFlagMap possible_flag_fns {
+                { "initialized"s, &Adapter::initialized    },
+                { "scanning"s,    &Adapter::scan_is_active },
+        };
+        static auto flag_check = [this](const PossibleFlagMap::value_type &pair) -> bool {
+            return pair.second(*this);
+        };
+
+        ranges::viewable_range auto flags = possible_flag_fns | views::filter(flag_check) | views::keys;
+        return { flags.begin(), flags.end() };
+    }
+
+    std::string Adapter::to_s() const {
+        std::ostringstream oss;
+        String superStr(rb_call_super(0, nullptr));
+        if (superStr.test() && superStr.length() > 0) {
+            std::string super(superStr.str());
+            super.pop_back();
+            oss << super;
+        } else {
+            oss << "#<" << Utils::human_type_name<decltype(*this)>();
+            oss << ":" << Utils::to_hex_addr(this);
+        }
+        oss << " ";
+        if (!initialized())  return oss.str() + "uninitialized>";
+        oss << "@address=\"" << address() << "\" ";
+        oss << Utils::join(status_flags(), "|");
+        oss << ">";
+        return oss.str();
+    }
+
+    void Adapter::ruby_mark() const {
+//    std::cout << "ruby_mark-ing adapter proxy: " << address() << std::endl;
+//    rb_gc_mark(self());
+        Rice::ruby_mark<RuBLE::PeripheralRegistry>(_peripheral_registry.get());
+//        rb_gc_mark(_peripheral_registry->self());
+        if (_on_scan_start) Rice::ruby_mark<RuBLE::Callback>(_on_scan_start.get());
+        if (_on_scan_stop) Rice::ruby_mark<RuBLE::Callback>(_on_scan_stop.get());
+        if (_on_scan_update) Rice::ruby_mark<RuBLE::Callback>(_on_scan_update.get());
+        if (_on_scan_find) Rice::ruby_mark<RuBLE::Callback>(_on_scan_find.get());
+    }
+
+    void Init_Adapter() {
+        define_class_under<SimpleBLE::Adapter>(rb_mRuBLEUnderlying, "SimpleBLEAdapter");
+        rb_cAdapter = define_class_under<Adapter>(rb_mRuBLE, "Adapter")
+                .define_singleton_function("bluetooth_enabled?", &Adapter::bluetooth_enabled) // returns bool
+                .define_singleton_function("get_adapters", &Adapter::get_ruby_adapters) // returns vector<Adapter>
+                .define_method("initialized?", &Adapter::initialized)
+                .define_method("identifier", &Adapter::identifier)
+                .define_method("address", &Adapter::address) // returns BluetoothAddress (alias of std::string)
+                .define_method("scan_start", &Adapter::scan_start)
+                .define_method("scan_stop", &Adapter::scan_stop)
+                .define_method("scan_for", &Adapter::scan_for) // takes (int timeout_ms)
+                .define_method("scanning?", &Adapter::scan_is_active)
+                .define_method("scan_get_results", &Adapter::scan_get_ruby_results) // returns vector<Peripheral>
+                .define_method("get_paired_peripherals",
+                               &Adapter::get_ruby_paired_peripherals) // returns vector<Peripheral>
+                .define_method("on_scan_start", &Adapter::on_scan_start, Arg("cb").keepAlive() = Qnil)
+                .define_method("on_scan_stop", &Adapter::on_scan_stop, Arg("cb").keepAlive() = Qnil)
+                .define_method("on_scan_update", &Adapter::on_scan_update, Arg("cb").keepAlive() = Qnil)
+                .define_method("on_scan_find", &Adapter::on_scan_find, Arg("cb").keepAlive() = Qnil)
+                ;
+//        define_class_under<std::shared_ptr<RuBLE::Adapter>>(rb_mRuBLE, "AdapterPtr");
+    }
+}
+
+

data/ext/ruble/bindings/Adapter.hpp

@@ -0,0 +1,85 @@
+#pragma clang diagnostic push
+#pragma ide diagnostic ignored "modernize-use-nodiscard"
+#pragma once
+
+#include "types/declarations.hpp"
+#include "containers/Callback.hpp"
+#include "management/Registry.hpp"
+
+#include <unordered_set>
+#include "utils/hash.hpp"
+
+namespace RuBLE {
+    namespace Rice = ::Rice;
+
+//    template<Identifiers::OwnerTypedResource T>
+//    class ResourceUniqueIdentifier;
+
+    class Adapter {
+    public:
+        using Owner = nullptr_t;
+        using DataObject [[maybe_unused]] = Data_Object<Adapter>;
+
+    protected:
+        VALUE _self;
+        std::shared_ptr<SimpleBLE::Adapter> _adapter;
+        BluetoothAddress _addr;
+        std::shared_ptr<Callback> _on_scan_start;
+        std::shared_ptr<Callback> _on_scan_stop;
+        std::shared_ptr<Callback> _on_scan_update;
+        std::shared_ptr<Callback> _on_scan_find;
+        std::shared_ptr<PeripheralRegistry> _peripheral_registry;
+
+    public:
+        Adapter() = delete;
+        Adapter(const SimpleBLE::Adapter &adapter);
+        ~Adapter() = default;
+
+        Object self() const;
+
+        SimpleBLE::Adapter &get();
+        const SimpleBLE::Adapter &get() const;
+
+        static bool bluetooth_enabled();
+        static std::vector<std::shared_ptr<Adapter>> get_adapters();
+        static Rice::Array get_ruby_adapters();
+        virtual bool initialized() const;
+        std::string identifier();
+        SimpleBLE::BluetoothAddress address() const;
+
+        void scan_start();
+        void scan_stop();
+        void scan_for(int timeout_ms);
+        bool scan_is_active() const;
+
+        void on_scan_start(Object on_scan_start);
+        void on_scan_stop(Object on_scan_stop);
+        void on_scan_update(Object on_scan_updated);
+        void on_scan_find(Object on_scan_found);
+
+        std::vector<std::shared_ptr<Peripheral>> scan_get_results();
+        std::vector<std::shared_ptr<Peripheral>> get_paired_peripherals();
+        Rice::Array scan_get_ruby_results();
+        Rice::Array get_ruby_paired_peripherals();
+        bool operator==(const SimpleBLE::BluetoothAddress &addr) const;
+        bool operator==(const Adapter &ap) const;
+
+        std::unordered_set<std::string> status_flags() const;
+        std::string to_s() const;
+
+//        constexpr ResourceUniqueIdentifier<Adapter> full_resource_identifier() const;
+//        constexpr BluetoothAddress this_resource_identifier() const;
+
+        void ruby_mark() const;
+
+        template<typename Key, class ProxyClass, class Value>
+        friend class Registry;
+
+        friend void Init_Adapter();
+        friend void Init_Registries();
+        friend void DeInit(VALUE);
+    };
+
+}
+
+#pragma clang diagnostic pop