ruble 0.0.3.alpha

data/ext/ruble/bindings/Characteristic.cpp

@@ -0,0 +1,171 @@
+#include "types/declarations.hpp"
+#include "bindings/Peripheral.hpp"
+#include "bindings/Service.hpp"
+#include "bindings/Characteristic.hpp"
+#include "bindings/Descriptor.hpp"
+
+#include <utility>
+#include "management/RubyQueue.hpp"
+#include "containers/Callback.hpp"
+#include "utils/inspection.hpp"
+
+namespace RuBLE {
+    Characteristic::Characteristic(const SimpleBLE::Characteristic &characteristic,
+                                   Owner *owner) :
+            _owner(owner),
+            _characteristic(std::make_shared<SimpleBLE::Characteristic>(characteristic)),
+            _uuid(_characteristic->uuid()),
+            _self(DataObject(*this)) {
+
+        if (capabilities()["notify"]) {
+            service()->notify(uuid(), [this](const ByteArray& data) {
+                RubyQueue::FnType fn = std::bind(&Characteristic::fire_on_notify, std::cref(*this), data);  // NOLINT(*-avoid-bind)
+                rubyQueue->push(fn);
+            });
+        }
+
+        if (capabilities()["indicate"]) {
+            service()->indicate(uuid(), [this](const ByteArray &data) {
+                RubyQueue::FnType fn = std::bind(&Characteristic::fire_on_indicate, std::cref(*this), data);  // NOLINT(*-avoid-bind)
+                rubyQueue->push(fn);
+            });
+        }
+    }
+
+    Object Characteristic::self() const {
+        return _self;
+    }
+
+    SimpleBLE::Characteristic &Characteristic::get() { return *_characteristic; }
+    const SimpleBLE::Characteristic &Characteristic::get() const { return *_characteristic; }
+
+    const std::map<BluetoothUUID, std::shared_ptr<Descriptor>> &Characteristic::descriptors() const {
+        if (_descriptors) return *_descriptors;
+        auto result = Descriptor::make_map(_characteristic->descriptors(), const_cast<Characteristic*>(this));
+        _descriptors = std::move(result);
+        return *_descriptors;
+    }
+
+    std::shared_ptr<Descriptor> Characteristic::operator[](const BluetoothUUID &descUuid) const {
+        // only check SimpleBLE backend for descriptor if not already instantiated
+        if (!_descriptors || !_descriptors->contains(descUuid)) const auto _result = descriptors();
+        return _descriptors->at(descUuid);
+        // TODO(?): catch (std::out_of_range &ex)
+    }
+
+    std::vector<std::string> Characteristic::capability_names() const { return capabilities().flag_name_strs(); }
+
+    ByteArray Characteristic::read(bool force) {
+        // if tracking is enabled, assume we'll get the value via callback
+        if (!force && value_tracking() && last_value()) return *last_value();
+
+        ByteArray value = service()->read(uuid());
+        record_new_value(value);
+        return std::move(value);
+    }
+
+    ByteArray Characteristic::read(const BluetoothUUID &descriptor) {
+        return service()->read(uuid(), descriptor);
+    }
+    void Characteristic::write(const BluetoothUUID &descriptor, const ByteArray &data) {
+        service()->write(uuid(), descriptor, data);
+    }
+    void Characteristic::write_request(const ByteArray &data) {
+        service()->write_request(uuid(), data);
+    }
+    void Characteristic::write_command(const ByteArray &data) {
+        service()->write_command(uuid(), data);
+    }
+
+    void Characteristic::set_on_notify(Object cb) {
+        if (!_on_notify) _on_notify = std::make_shared<Callback>(2);
+        _on_notify->set(std::move(cb));
+    }
+
+    void Characteristic::set_on_indicate(Object cb) {
+        if (!_on_indicate) _on_indicate = std::make_shared<Callback>(2);
+        _on_indicate->set(std::move(cb));
+    }
+
+    void Characteristic::fire_on_notify(const ByteArray &data) const {
+        if (DEBUG) std::cout << "Characteristic::fire_on_notify called with " << data.inspect() << std::endl;
+        if (!record_new_value(data)) return; // if value tracking is enabled, skip callback unless value changed
+        if (_on_notify) _on_notify->fire(Rice::detail::To_Ruby<SimpleBLE::ByteArray>().convert(data), self());
+    }
+
+    void Characteristic::fire_on_indicate(const ByteArray &data) const {
+        if (DEBUG) std::cout << "Characteristic::fire_on_indicate called with " << data.inspect() << std::endl;
+        if (_on_indicate) _on_indicate->fire(Rice::detail::To_Ruby<SimpleBLE::ByteArray>().convert(data), self());
+    }
+
+    void Characteristic::unsubscribe() {
+        service()->unsubscribe(uuid());
+    }
+
+    std::string Characteristic::to_s() const {
+        std::ostringstream oss;
+        oss << Utils::basic_object_inspect_start(*this) << " ";
+        oss << "@uuid=" << uuid() << " ";
+        oss << "@capabilities=" << capabilities();
+//        oss << "#characteristics=" << characteristics().size();
+        oss << ">";
+        return oss.str();
+    }
+
+    Rice::String Characteristic::inspect() const {
+        return to_s();
+    }
+
+
+    void Characteristic::ruby_mark() const {
+        rb_gc_mark(self());
+        CharacteristicValueTracker::ruby_mark();
+        if (_on_indicate) Rice::ruby_mark(_on_indicate.get());
+        if (_on_notify) Rice::ruby_mark(_on_notify.get());
+        if (_descriptors) {
+            for (const auto &[uuid, descriptor]: *_descriptors) Rice::ruby_mark(descriptor.get());
+        }
+    }
+
+    void Init_Characteristic() {
+        // FIXME: A bunch of these classes inherit from abstract base classes (e.g. BaseAdapter),
+        // and are also subclassed in different implementations (I think).
+        // Do we need the constructor and methods to return/receive pointers to work well
+        // (so the right virtual functions are called)? Not sure if rice is handling that all,
+        // or just not seeing any obvious bugs yet because the base classes are so minimal.
+        rb_cCharacteristic = define_class_under<Characteristic>(rb_mRuBLE, "Characteristic");
+
+        using CapabilityType = Characteristic::Capability;
+        rb_cCharacteristicCapabilityType = Utils::define_described_enum<CapabilityType>("CapabilityType", rb_cCharacteristic);
+
+        using CababilityFlags [[maybe_unused]] = Characteristic::CapabilityFlags;
+        //        auto rb_cCharacteristicCapabilityFlags = define_class_under<CapabilityFlags>(rb_cCharacteristic, "CapabilityFlags")
+//                .define_method("flag_names", &CapabilityFlags::flag_names)
+//                ;
+
+        rb_cCharacteristic
+                .define_method("uuid", &Characteristic::uuid) // returns BluetoothUUID
+                .define_method("capabilities", &Characteristic::capability_names)
+                .define_method("can_read?", &Characteristic::can_read)
+                .define_method("can_write_request?", &Characteristic::can_write_request)
+                .define_method("can_write_command?", &Characteristic::can_write_command)
+                .define_method("can_notify?", &Characteristic::can_notify)
+                .define_method("can_indicate?", &Characteristic::can_indicate)
+                .define_method<Characteristic::ExposedReadFn>("read", &Characteristic::read, Arg("force") = false)
+                .define_method("write", &Characteristic::write)
+                .define_method("write_request", &Characteristic::write_request)
+                .define_method("write_command", &Characteristic::write_command)
+                .define_method("set_on_notify", &Characteristic::set_on_notify)
+                .define_method("set_on_indicate", &Characteristic::set_on_indicate)
+//                .define_method("unsubscribe", &Characteristic::unsubscribe)
+                .define_method("to_s", &Characteristic::to_s)
+                .define_method("inspect", &Characteristic::inspect)
+                .define_method("value_tracking", &Characteristic::value_tracking)
+                .define_method("value_tracking?", &Characteristic::value_tracking)
+                .define_method("value_tracking=", &Characteristic::set_value_tracking)
+                .define_method("last_value", &Characteristic::last_value)
+                ;
+        define_class_under<std::shared_ptr<RuBLE::Characteristic>>(rb_mRuBLE, "CharacteristicPtr");
+
+    }
+}

data/ext/ruble/bindings/Characteristic.hpp

@@ -0,0 +1,132 @@
+#pragma once
+
+#include "management/RubyQueue.hpp"
+#include "containers/NamedBitSet.hpp"
+#include "bindings/Descriptor.hpp"
+#include "bindings/Service.hpp"
+#include "containers/ByteArray.hpp"
+#include "utils/hash.hpp"
+#include "utils/inspection.hpp"
+#include "concerns/CharacteristicValueTracker.hpp"
+
+namespace RuBLE {
+
+    BOOST_DEFINE_FIXED_ENUM_CLASS(
+            CharacteristicCapabilityType,
+            std::size_t,
+            READ,
+            WRITE_REQUEST,
+            WRITE_COMMAND,
+            NOTIFY,
+            INDICATE
+    )
+    class Service;
+    class Characteristic : public CharacteristicValueTracker {
+    public:
+        static constexpr std::string_view CAPABILITY_NAMES[] = {
+                "read",
+                "write_request",
+                "write_command",
+                "notify",
+                "indicate"
+        };
+        using Capability = CharacteristicCapabilityType;
+        using CapabilityFlags = RuBLE::NamedBitSet<CAPABILITY_NAMES>;
+        using DataObject = Data_Object<Characteristic>;
+        using Owner = Service;
+        using CallbackFnType [[maybe_unused]] = std::function<void(ByteArray payload)>;
+        using DescriptorMap = std::map<BluetoothUUID, std::shared_ptr<Descriptor>>;
+    protected:
+        Owner *_owner;
+        std::shared_ptr<SimpleBLE::Characteristic> _characteristic;
+        BluetoothUUID _uuid;
+        std::shared_ptr<Callback> _on_notify;
+        std::shared_ptr<Callback> _on_indicate;
+        mutable std::optional<CapabilityFlags> _capabilities;
+        // NB: this is the only class where we're not using a Registry<>
+        // This can be a case study in if we can remove a ton of the registry stuff
+        // now that I figured out garbage collection
+        mutable std::optional<DescriptorMap> _descriptors;
+
+        VALUE _self = Qnil;
+
+        void fire_on_notify(const ByteArray &data) const;
+        void fire_on_indicate(const ByteArray &data) const;
+    public:
+        [[nodiscard]] Object self() const;
+        Characteristic() = delete;
+        Characteristic(const SimpleBLE::Characteristic&, Owner*);
+        SimpleBLE::Characteristic &get();
+        [[nodiscard]] const SimpleBLE::Characteristic &get() const;
+        [[nodiscard]] constexpr const Owner *owner() const;
+        constexpr Owner *owner();
+        [[nodiscard]] constexpr const Service *service() const;
+        constexpr Service *service();
+
+        [[nodiscard]] constexpr const BluetoothUUID &uuid() const;
+//        constexpr ResourceUniqueIdentifier<Characteristic> full_resource_identifier() const;
+//        constexpr BluetoothUUID this_resource_identifier() const;
+
+        [[nodiscard]] const std::map<BluetoothUUID, std::shared_ptr<Descriptor>> &descriptors() const;
+        [[nodiscard]] std::shared_ptr<Descriptor> operator[](const BluetoothUUID &descUuid) const;
+        [[nodiscard]] constexpr const CapabilityFlags &capabilities() const;
+
+        [[nodiscard]] std::vector<std::string> capability_names() const;
+        [[nodiscard]] constexpr bool can_read() const;
+        [[nodiscard]] constexpr bool can_write_request() const;
+        [[nodiscard]] constexpr bool can_write_command() const;
+        [[nodiscard]] constexpr bool can_notify() const override;
+        [[nodiscard]] constexpr bool can_indicate() const;
+
+        [[nodiscard]] ByteArray read(bool force = false);
+        [[nodiscard]] ByteArray read(const BluetoothUUID &descriptor);
+        void write(const BluetoothUUID &descriptor, const ByteArray &data);
+        void write_request(const ByteArray &data);
+        void write_command(const ByteArray &data);
+
+        void set_on_notify(Object cb);
+        void set_on_indicate(Object cb);
+        void unsubscribe();
+
+        [[nodiscard]] std::string to_s() const;
+        [[nodiscard]] Rice::String inspect() const;
+        // bool operator==(const Characteristic &ap) const;
+        // bool operator==(const Characteristic &ap) const;
+        void ruby_mark() const override;
+
+        friend void Init_Characteristic();
+        friend void Init_Registries();
+        template<typename, class, class> friend class Registry;
+        using ExposedReadFn = ByteArray(Characteristic::*)(bool);
+    };
+
+    constexpr const Characteristic::Owner *Characteristic::owner() const { return _owner; }
+
+    constexpr Characteristic::Owner *Characteristic::owner() { return _owner; }
+
+    constexpr const Service *Characteristic::service() const { return owner(); }
+
+    constexpr Service *Characteristic::service() { return owner(); }
+
+    constexpr const BluetoothUUID &Characteristic::uuid() const { return _uuid; }
+
+
+//    constexpr BluetoothUUID Characteristic::this_resource_identifier() const { return _uuid; }
+
+    constexpr const Characteristic::CapabilityFlags &Characteristic::capabilities() const {
+        if (_capabilities) return *_capabilities;
+        _capabilities = std::make_optional<CapabilityFlags>(_characteristic->capabilities());
+        return *_capabilities;
+    }
+
+    constexpr bool Characteristic::can_read() const { return capabilities()["read"]; }
+
+    constexpr bool Characteristic::can_write_request() const { return capabilities()["write_request"]; }
+
+    constexpr bool Characteristic::can_write_command() const { return capabilities()["write_command"]; }
+
+    constexpr bool Characteristic::can_notify() const { return capabilities()["notify"]; }
+
+    constexpr bool Characteristic::can_indicate() const { return capabilities()["indicate"]; }
+}
+

data/ext/ruble/bindings/Descriptor.cpp

@@ -0,0 +1,34 @@
+#include "bindings/Descriptor.hpp"
+#include "bindings/Characteristic.hpp"
+
+namespace RuBLE {
+    Descriptor::Descriptor(BluetoothUUID uuid, Descriptor::Owner *owner) :
+        _owner(owner), _uuid(std::move(uuid)),  _self(DataObject(*this))  {}
+
+    Descriptor::Descriptor(const SimpleBLE::Descriptor &descriptor, Descriptor::Owner *owner) :
+            Descriptor(const_cast<SimpleBLE::Descriptor&>(descriptor).uuid(), owner) {}
+
+    Object Descriptor::self() const { return _self; }
+
+    [[nodiscard]] ByteArray Descriptor::read() { return characteristic()->read(uuid()); }
+
+    void Descriptor::write(const ByteArray &data) { characteristic()->write(uuid(), data); }
+
+
+    Rice::String Descriptor::inspect() const {
+        return to_s();
+    }
+
+
+
+    void Init_Descriptor() {
+        rb_cDescriptor = define_class_under<Descriptor>(rb_mRuBLE, "Descriptor")
+                .define_method("uuid", &Descriptor::uuid) // returns BluetoothUUID
+                .define_method("inspect", &Descriptor::inspect)
+                .define_method("read", &Descriptor::read)
+                .define_method("write", &Descriptor::write)
+                ;
+    }
+
+}
+

data/ext/ruble/bindings/Descriptor.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+#include "types/declarations.hpp"
+#include <utility>
+#include <compare>
+#include "utils/inspection.hpp"
+
+namespace RuBLE {
+    class Characteristic;
+    class Descriptor {
+    public:
+        using DataObject = Descriptor_DO;
+        using Owner = Characteristic;
+    protected:
+        BluetoothUUID _uuid;
+        Owner *_owner = nullptr;
+        VALUE _self = Qnil;
+    public:
+        static std::map<BluetoothUUID, std::shared_ptr<Descriptor>> make_map(const auto &range, Descriptor::Owner *owner) {
+            std::map<BluetoothUUID, std::shared_ptr<Descriptor>> result;
+            for (const auto &descriptor : range) {
+                auto descPtr = std::make_shared<Descriptor>(descriptor, owner);
+                result.emplace(descPtr->uuid(), std::move(descPtr));
+            }
+            return result;
+        }
+
+        Descriptor() = delete;
+        Descriptor(BluetoothUUID uuid, Owner *owner);
+        Descriptor(const SimpleBLE::Descriptor &descriptor, Owner *owner);
+
+        [[nodiscard]] Object self() const;
+
+        [[nodiscard]] const Owner *owner() const { return _owner; }
+        constexpr Owner *owner() { return _owner; }
+
+        [[nodiscard]] const Characteristic *characteristic() const { return _owner; }
+
+        constexpr Characteristic *characteristic() { return _owner; }
+
+        [[nodiscard]] constexpr const BluetoothUUID &uuid() const { return _uuid; }
+
+//        [[nodiscard]] constexpr ResourceUniqueIdentifier<Descriptor> full_resource_identifier() const;
+//        [[nodiscard]] constexpr BluetoothUUID this_resource_identifier() const;
+
+        ByteArray read();
+        void write(const ByteArray &data);
+
+        [[nodiscard]] constexpr std::string to_s() const {
+            return Utils::basic_object_inspect_start(*this) + " " + uuid() + ">";
+        }
+        [[nodiscard]] Rice::String inspect() const;
+
+        [[nodiscard]] constexpr auto operator<=>(const Descriptor &other) const;
+
+    };
+
+
+    constexpr auto Descriptor::operator<=>(const Descriptor &other) const {
+        return uuid() <=> other.uuid();
+    }
+
+} // RuBLE
+
+constexpr std::ostream &operator<<(std::ostream &os, const RuBLE::Descriptor &d) { return os << d.to_s(); }
+
+
+
+

data/ext/ruble/bindings/Peripheral.cpp

@@ -0,0 +1,212 @@
+#include "types/declarations.hpp"
+#include "containers/NamedBitSet.hpp"
+#include "bindings/Peripheral.hpp"
+#include "management/RubyQueue.hpp"
+#include "containers/Callback.hpp"
+#include "bindings/Service.hpp"
+#include "management/Registry.hpp"
+#include "management/RegistryFactory.hpp"
+
+namespace RuBLE {
+    Peripheral::Peripheral(const SimpleBLE::Peripheral &peripheral,
+                           Owner *owner) :
+            _owner(owner),
+            _peripheral(std::make_shared<SimpleBLE::Peripheral>(peripheral)),
+            _addr(_peripheral->address()),
+            _addr_type(_peripheral->address_type()),
+            _on_connected(std::make_shared<Callback>(1)),
+            _on_disconnected(std::make_shared<Callback>(1)),
+            _self(Peripheral_DO(*this)),
+            _service_registry(serviceRegistryFactory->registry(this)) {
+        _peripheral->set_callback_on_connected([this]() {
+            RubyQueue::FnType fn = [this]() -> void { _on_connected->fire(self()); };
+            if (_on_connected) rubyQueue->push(fn);
+        });
+        _peripheral->set_callback_on_disconnected([this]() {
+            RubyQueue::FnType fn = [this]() -> void { _on_disconnected->fire(self()); };
+            if (_on_disconnected) rubyQueue->push(fn);
+        });
+    }
+
+    bool Peripheral::initialized() const { return _peripheral->initialized(); }
+
+    std::string Peripheral::identifier() const { return _peripheral->identifier(); }
+
+
+    std::map<uint16_t, ByteArray> Peripheral::manufacturer_data() const {
+        auto data = _peripheral->manufacturer_data();
+        return { data.begin(), data.end() };
+    }
+
+    Object Peripheral::self() const {
+        return _self;
+    }
+
+    const Peripheral::Owner *Peripheral::owner() const { return _owner; }
+    Peripheral::Owner *Peripheral::owner() { return _owner; }
+    SimpleBLE::Peripheral &Peripheral::get() { return *_peripheral; }
+    const SimpleBLE::Peripheral &Peripheral::get() const { return *_peripheral; }
+
+    bool Peripheral::is_connected() const { return _peripheral->is_connected(); }
+
+    bool Peripheral::is_connectable() const { return _peripheral->is_connectable(); }
+
+    bool Peripheral::is_paired() const { return _peripheral->is_paired(); }
+
+    Peripheral::StatusFlagSet Peripheral::status_flags() const {
+        using StatusFlagTestMap = std::unordered_map<std::string, std::function<bool(const Peripheral&)>>;
+        static const StatusFlagTestMap status_flag_testers {
+                {"initialized"s, &Peripheral::initialized},
+                {"paired"s,      &Peripheral::is_paired},
+                {"connected"s,   &Peripheral::is_connected},
+                {"connectable"s, &Peripheral::is_connectable}
+        };
+        return { status_flag_testers, *this };
+    }
+
+    std::vector<std::string_view> Peripheral::statuses() const {
+        return status_flags().flag_names();
+    }
+
+    int16_t Peripheral::rssi() const { return _peripheral->rssi(); }
+
+    int16_t Peripheral::tx_power() const { return _peripheral->tx_power(); }
+
+    uint16_t Peripheral::mtu() const { return _peripheral->mtu(); }
+
+    void Peripheral::connect() { _peripheral->connect(); }
+
+    void Peripheral::disconnect() { _peripheral->disconnect(); }
+
+    void Peripheral::unpair() { _peripheral->unpair(); }
+
+    const std::map<BluetoothUUID, std::shared_ptr<Service>> &Peripheral::services() const {
+        if (!rb_during_gc()) {
+            // we can't create new services during GC
+            for (const auto &c : _peripheral->services()) _service_registry->fetch(c);
+        }
+        return _service_registry->data();
+//        std::vector<SimpleBLE::Service> unwrappedServices = _peripheral->services();
+//        auto objects = _service_registry->map_to_objects(unwrappedServices);
+//        std::function<BluetoothUUID(const Service&)> mapFn = &Service::uuid;
+//        std::map<BluetoothUUID, std::shared_ptr<Service>> result =
+//                map_by<BluetoothUUID, std::shared_ptr<Service>>(objects, mapFn);
+//        return result;
+    }
+
+    std::shared_ptr<Service> Peripheral::operator[](const BluetoothUUID &svcUuid) const {
+        // only check SimpleBLE backend for descriptor if not already instantiated
+        try {
+            if (_service_registry || !_service_registry->contains(svcUuid)) const auto _result = services();
+            return _service_registry->at(svcUuid);
+        } catch (std::out_of_range &ex) {
+            return {};
+        }
+    }
+
+    ByteArray Peripheral::read(const BluetoothUUID &service, const BluetoothUUID &characteristic) {
+        return _peripheral->read(service, characteristic);
+    }
+
+    void Peripheral::write_request(const BluetoothUUID &service, const BluetoothUUID &characteristic,
+                                   const ByteArray &data) {
+        return _peripheral->write_request(service, characteristic, data);
+    }
+
+    void Peripheral::write_command(const BluetoothUUID &service, const BluetoothUUID &characteristic,
+                                   const ByteArray &data) {
+        return _peripheral->write_command(service, characteristic, data);
+    }
+
+    void Peripheral::notify(const BluetoothUUID &service, const BluetoothUUID &characteristic,
+                            std::function<void(ByteArray)> callback) {
+        // FIXME: make sure we don't have a GC problem with this callback
+        return _peripheral->notify(service, characteristic, callback);
+    }
+
+    void Peripheral::indicate(const BluetoothUUID &service, const BluetoothUUID &characteristic,
+                              std::function<void(ByteArray)> callback) {
+        // FIXME: make sure we don't have a GC problem with this callback
+        return _peripheral->indicate(service, characteristic, callback);
+    }
+
+    void Peripheral::unsubscribe(const BluetoothUUID &service, const BluetoothUUID &characteristic) {
+        return _peripheral->unsubscribe(service, characteristic);
+    }
+
+    ByteArray Peripheral::read(const BluetoothUUID &service, const BluetoothUUID &characteristic,
+                               const BluetoothUUID &descriptor) {
+        return _peripheral->read(service, characteristic, descriptor);
+    }
+
+    void Peripheral::write(const BluetoothUUID &service, const BluetoothUUID &characteristic,
+                           const BluetoothUUID &descriptor, const ByteArray &data) {
+        return _peripheral->write(service, characteristic, descriptor, data);
+    }
+
+//bool Peripheral::operator==(const Peripheral &p) const {
+//    return _peripheral && _peripheral->underlying() == p.underlying();
+//}
+
+//bool Peripheral::operator==(const Peripheral &p) const { return _peripheral == p._peripheral; }
+
+    void Peripheral::on_connect(Object on_connect) {
+        _on_connected->set(on_connect);
+    }
+
+    void Peripheral::on_disconnect(Object on_disconnect) {
+        _on_disconnected->set(on_disconnect);
+    }
+
+    std::string Peripheral::to_s() const {
+        std::ostringstream oss;
+        oss << Utils::basic_object_inspect_start(*this) << " ";
+        if (!initialized())  return oss.str() + "uninitialized>";
+        oss << "@address[" << Utils::enum_val_as_string(address_type()) << "]=\"" << address() << "\" ";
+        oss << "@identifier=\"" << identifier() << "\" ";
+        oss << "@rssi=" << rssi() << " ";
+        oss << "@tx_power=" << tx_power() << " ";
+        oss << "@mtu=" << mtu() << " ";
+        oss << "svc_count=" << _peripheral->services().size() << " ";
+        oss << Utils::join(statuses(), "|");
+//        std::map<uint16_t, SimpleBLE::ByteArray> manufacturer_data() const;
+        oss << ">";
+        return oss.str();
+    }
+
+    void Peripheral::ruby_mark() const {
+        rb_gc_mark(self());
+        if (_on_connected) _on_connected->ruby_mark();
+        if (_on_disconnected) _on_disconnected->ruby_mark();
+        Rice::ruby_mark(_service_registry.get());
+    }
+
+
+    void Init_Peripheral() {
+        define_class_under<SimpleBLE::Peripheral>(rb_mRuBLEUnderlying, "Peripheral");
+        rb_cPeripheral = define_class_under<Peripheral>(rb_mRuBLE, "Peripheral")
+//                .define_constructor(Constructor<Peripheral>())
+                .define_method("inspect", &Peripheral::to_s)
+                .define_method("initialized?", &Peripheral::initialized)
+                .define_method("identifier", &Peripheral::identifier)
+                .define_method("address", &Peripheral::address) // returns BluetoothAddress (alias for string)
+                .define_method("address_type", &Peripheral::address_type)
+                .define_method("rssi", &Peripheral::rssi)
+                .define_method("tx_power", &Peripheral::tx_power)
+                .define_method("mtu", &Peripheral::mtu)
+                .define_method("connect", &Peripheral::connect)
+                .define_method("disconnect", &Peripheral::disconnect)
+                .define_method("connected?", &Peripheral::is_connected)
+                .define_method("connectable?", &Peripheral::is_connectable)
+                .define_method("paired?", &Peripheral::is_paired)
+                .define_method("unpair", &Peripheral::unpair)
+                        // TODO: this isn't returning any useful data. Should we keep it? (Or is there a way to parse?)
+                .define_method("manufacturer_data", &Peripheral::manufacturer_data)
+                .define_method("on_connect", &Peripheral::on_connect, Arg("cb").keepAlive())
+                .define_method("on_disconnect", &Peripheral::on_disconnect, Arg("cb").keepAlive())
+                .define_singleton_attr("unpair_all_on_exit", &Peripheral::unpair_all_on_exit, Rice::AttrAccess::ReadWrite)
+                ;
+        define_class_under<std::shared_ptr<RuBLE::Peripheral>>(rb_mRuBLE, "PeripheralPtr");
+    }
+}
+