simpleble 0.0.1

data/vendor/simpleble/simpledbus/src/base/Path.cpp

@@ -0,0 +1,129 @@
+#include "simpledbus/base/Path.h"
+
+#include <algorithm>
+
+namespace SimpleDBus {
+
+// TODO: Add path validation and throw exception if invalid
+
+size_t Path::count_elements(const std::string& path) {
+    if (path.empty() || path == "/") {
+        return 0;
+    }
+
+    return std::count(path.begin(), path.end(), '/');
+}
+
+std::vector<std::string> Path::split_elements(const std::string& path) {
+    std::vector<std::string> elements;
+
+    if (path.empty() || path == "/") {
+        return elements;
+    }
+
+    // Note: Skip the first element, which is the root
+    std::string::const_iterator it = path.begin() + 1;
+    std::string::const_iterator end = path.end();
+
+    while (it != end) {
+        std::string::const_iterator next = std::find(it, end, '/');
+        elements.push_back(std::string(it, next));
+        it = next;
+        if (it != end) {
+            ++it;
+        }
+    }
+
+    return elements;
+}
+
+std::string Path::fetch_elements(const std::string& path, size_t count) {
+    if (count == 0) {
+        return "/";
+    }
+
+    if (count > count_elements(path)) {
+        // TODO: Should we throw an exception?
+        return path;
+    }
+
+    std::vector<std::string> elements = split_elements(path);
+    std::string result;
+
+    for (size_t i = 0; i < count; i++) {
+        result += "/" + elements[i];
+    }
+
+    return result;
+}
+
+bool Path::is_descendant(const std::string& base, const std::string& path) {
+    if (base.empty() || path.empty()) {
+        return false;
+    }
+
+    if (base == path) {
+        return false;
+    }
+
+    if (base == "/") {
+        return true;
+    }
+
+    return path.rfind(base) == 0;
+}
+
+bool Path::is_ascendant(const std::string& base, const std::string& path) {
+    if (base.empty() || path.empty()) {
+        return false;
+    }
+
+    if (base == path) {
+        return false;
+    }
+
+    return !is_descendant(base, path);
+}
+
+bool Path::is_child(const std::string& base, const std::string& path) {
+    if (base.empty() || path.empty()) {
+        return false;
+    }
+
+    if (base == path) {
+        return false;
+    }
+
+    if (!is_descendant(base, path)) {
+        return false;
+    }
+
+    return count_elements(base) + 1 == count_elements(path);
+}
+
+bool Path::is_parent(const std::string& base, const std::string& path) {
+    if (base.empty() || path.empty()) {
+        return false;
+    }
+
+    if (base == path) {
+        return false;
+    }
+
+    if (!is_ascendant(base, path)) {
+        return false;
+    }
+
+    return count_elements(base) - 1 == count_elements(path);
+}
+
+std::string Path::next_child(const std::string& base, const std::string& path) {
+    return fetch_elements(path, count_elements(base) + 1);
+}
+
+std::string Path::next_child_strip(const std::string& base, const std::string& path) {
+    const std::string child = next_child(base, path);
+    return child.substr(base.length() + 1);
+}
+
+}  // namespace SimpleDBus

data/vendor/simpleble/simpledbus/src/interfaces/ObjectManager.cpp

@@ -0,0 +1,58 @@
+#include <simpledbus/interfaces/ObjectManager.h>
+
+using namespace SimpleDBus;
+
+const AutoRegisterInterface<ObjectManager> ObjectManager::registry{
+    "org.freedesktop.DBus.ObjectManager",
+    // clang-format off
+    [](std::shared_ptr<Connection> conn, const std::string& bus_name, const std::string& path, const Holder& options) -> std::shared_ptr<SimpleDBus::Interface> {
+        return std::static_pointer_cast<SimpleDBus::Interface>(std::make_shared<ObjectManager>(conn, bus_name, path));
+    }
+    // clang-format on
+};
+
+ObjectManager::ObjectManager(std::shared_ptr<Connection> conn, std::string bus_name, std::string path)
+    : Interface(conn, bus_name, path, "org.freedesktop.DBus.ObjectManager") {}
+
+Holder ObjectManager::GetManagedObjects(bool use_callbacks) {
+    Message query_msg = Message::create_method_call(_bus_name, _path, _interface_name, "GetManagedObjects");
+    Message reply_msg = _conn->send_with_reply_and_block(query_msg);
+    Holder managed_objects = reply_msg.extract();
+    // TODO: Remove immediate callback support.
+    if (use_callbacks) {
+        auto managed_object = managed_objects.get_dict_object_path();
+        for (auto& [path, options] : managed_object) {
+            if (InterfacesAdded) {
+                InterfacesAdded(path, options);
+            }
+        }
+    }
+    return managed_objects;
+}
+
+void ObjectManager::message_handle(Message& msg) {
+    if (msg.is_signal(_interface_name, "InterfacesAdded")) {
+        std::string path = msg.extract().get_string();
+        msg.extract_next();
+        Holder options = msg.extract();
+        if (InterfacesAdded) {
+            InterfacesAdded(path, options);
+        }
+    } else if (msg.is_signal(_interface_name, "InterfacesRemoved")) {
+        std::string path = msg.extract().get_string();
+        msg.extract_next();
+        Holder options = msg.extract();
+        if (InterfacesRemoved) {
+            InterfacesRemoved(path, options);
+        }
+        // TODO: Make a call directly to the proxy to do this?
+
+    } else if (msg.is_method_call(_interface_name, "GetManagedObjects")) {
+        // TODO: Implement this.
+        // SimpleDBus::Holder result = _proxy->path_collect();
+
+        // SimpleDBus::Message reply = SimpleDBus::Message::create_method_return(msg);
+        // reply.append_argument(result, "a{oa{sa{sv}}}");
+        // _conn->send(reply);
+    }
+}

data/vendor/simpleble/simpledbus/test/src/helpers/PythonRunner.cpp

@@ -0,0 +1,53 @@
+#include "PythonRunner.h"
+#include <Python.h>
+#include <mutex>
+
+#include <csignal>
+
+PythonRunner::PythonRunner(const std::string& script_path) : _script_path(script_path) {
+    // In order to get Python to properly find relative imports, the current location
+    // of the executable needs to be added to the Python path.
+    _import_path = std::filesystem::canonical("/proc/self/exe").parent_path();
+}
+
+PythonRunner::~PythonRunner() { uninit(); }
+
+void PythonRunner::init() {
+    _async_thread = new std::thread(&PythonRunner::_async_thread_function, this);
+    while (!_python_initialized) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+}
+
+void PythonRunner::uninit() {
+    if (Py_IsInitialized()) {
+        // This is a hack to get the Python interpreter to exit cleanly.
+        raise(SIGINT);
+    }
+    if (_async_thread) {
+        while (!_async_thread->joinable()) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+        }
+        _async_thread->join();
+        delete _async_thread;
+        _async_thread = nullptr;
+        _python_initialized = false;
+    }
+}
+
+void PythonRunner::_async_thread_function() {
+    Py_InitializeEx(0);
+
+    // Append the required import path to the Python path.
+    PyRun_SimpleString("import sys");
+    PyRun_SimpleString(("sys.path.append('" + _import_path.string() + "')").c_str());
+    _python_initialized = true;
+
+    // Run the script.
+    std::string full_script_path = (_import_path / _script_path).string();
+    FILE* fp = fopen(full_script_path.c_str(), "r");
+    PyRun_SimpleFile(fp, full_script_path.c_str());
+    fclose(fp);
+    Py_Finalize();
+}

data/vendor/simpleble/simpledbus/test/src/helpers/PythonRunner.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <atomic>
+#include <filesystem>
+#include <string>
+#include <thread>
+
+class PythonRunner {
+  public:
+    PythonRunner(const std::string& script_path);
+    ~PythonRunner();
+    PythonRunner(PythonRunner& other) = delete;    // Remove the copy constructor
+    void operator=(const PythonRunner&) = delete;  // Remove the copy assignment
+
+    void init();
+    void uninit();
+
+  private:
+    std::atomic_bool _python_initialized = {false};
+    std::filesystem::path _import_path;
+    std::string _script_path;
+    std::thread* _async_thread;
+    void _async_thread_function();
+};

data/vendor/simpleble/simpledbus/test/src/main.cpp

@@ -0,0 +1,16 @@
+
+#include <gtest/gtest.h>
+#include "helpers/PythonRunner.h"
+
+int main(int argc, char** argv) {
+    PythonRunner runner("test_fixture.py");
+
+    runner.init();
+
+    ::testing::InitGoogleTest(&argc, argv);
+    auto test_result = RUN_ALL_TESTS();
+
+    runner.uninit();
+
+    return test_result;
+}

data/vendor/simpleble/simpledbus/test/src/test_holder.cpp

@@ -0,0 +1,184 @@
+#include <gtest/gtest.h>
+
+#include <simpledbus/base/Holder.h>
+
+#include <any>
+#include <map>
+#include <string>
+#include <variant>
+
+using namespace SimpleDBus;
+
+TEST(Holder, Boolean) {
+    Holder h = Holder::create_boolean(true);
+    EXPECT_EQ(h.get_boolean(), true);
+
+    EXPECT_EQ(h.type(), Holder::Type::BOOLEAN);
+
+    EXPECT_EQ(h.signature(), "b");
+
+    EXPECT_EQ(h.represent(), "true\n");
+}
+
+TEST(Holder, Byte) {
+    Holder h = Holder::create_byte(0x12);
+    EXPECT_EQ(h.get_byte(), 0x12);
+
+    EXPECT_EQ(h.type(), Holder::Type::BYTE);
+
+    EXPECT_EQ(h.signature(), "y");
+
+    EXPECT_EQ(h.represent(), "18\n");
+}
+
+TEST(Holder, Int16) {
+    Holder h = Holder::create_int16(0x1234);
+    EXPECT_EQ(h.get_int16(), 0x1234);
+
+    EXPECT_EQ(h.type(), Holder::Type::INT16);
+
+    EXPECT_EQ(h.signature(), "n");
+
+    EXPECT_EQ(h.represent(), "4660\n");
+}
+
+TEST(Holder, Int32) {
+    Holder h = Holder::create_int32(0x12345678);
+    EXPECT_EQ(h.get_int32(), 0x12345678);
+
+    EXPECT_EQ(h.type(), Holder::Type::INT32);
+
+    EXPECT_EQ(h.signature(), "i");
+
+    EXPECT_EQ(h.represent(), "305419896\n");
+}
+
+TEST(Holder, Int64) {
+    Holder h = Holder::create_int64(0x123456789abcdef0);
+    EXPECT_EQ(h.get_int64(), 0x123456789abcdef0);
+
+    EXPECT_EQ(h.type(), Holder::Type::INT64);
+
+    EXPECT_EQ(h.signature(), "x");
+
+    EXPECT_EQ(h.represent(), "1311768467463790320\n");
+}
+
+TEST(Holder, Double) {
+    Holder h = Holder::create_double(3.14);
+    EXPECT_EQ(h.get_double(), 3.14);
+
+    EXPECT_EQ(h.type(), Holder::Type::DOUBLE);
+
+    EXPECT_EQ(h.signature(), "d");
+
+    EXPECT_EQ(h.represent(), "3.14\n");
+}
+
+TEST(Holder, String) {
+    Holder h = Holder::create_string("Hello, world!");
+    EXPECT_EQ(h.get_string(), "Hello, world!");
+
+    EXPECT_EQ(h.type(), Holder::Type::STRING);
+
+    EXPECT_EQ(h.signature(), "s");
+
+    EXPECT_EQ(h.represent(), "Hello, world!\n");
+}
+
+TEST(Holder, ObjectPath) {
+    Holder h = Holder::create_object_path("/foo/bar");
+    EXPECT_EQ(h.get_object_path(), "/foo/bar");
+
+    EXPECT_EQ(h.type(), Holder::Type::OBJ_PATH);
+
+    EXPECT_EQ(h.signature(), "o");
+
+    EXPECT_EQ(h.represent(), "/foo/bar\n");
+}
+
+TEST(Holder, Signature) {
+    Holder h = Holder::create_signature("s");
+    EXPECT_EQ(h.get_signature(), "s");
+
+    EXPECT_EQ(h.type(), Holder::Type::SIGNATURE);
+
+    EXPECT_EQ(h.signature(), "g");
+
+    EXPECT_EQ(h.represent(), "s\n");
+}
+
+TEST(Holder, ArrayHomogeneous) {
+    Holder h = Holder::create_array();
+    h.array_append(Holder::create_int32(42));
+
+    EXPECT_EQ(h.get_array().size(), 1);
+    EXPECT_EQ(h.get_array()[0].get_int32(), 42);
+
+    EXPECT_EQ(h.type(), Holder::Type::ARRAY);
+
+    EXPECT_EQ(h.signature(), "ai");
+
+    EXPECT_EQ(h.represent(), "Array:\n  42\n");
+}
+
+TEST(Holder, ArrayHeterogeneous) {
+    Holder h = Holder::create_array();
+    h.array_append(Holder::create_int32(42));
+    h.array_append(Holder::create_string("Hello, world!"));
+
+    EXPECT_EQ(h.get_array().size(), 2);
+
+    EXPECT_EQ(h.type(), Holder::Type::ARRAY);
+
+    EXPECT_EQ(h.signature(), "av");
+
+    EXPECT_EQ(h.represent(), "Array:\n  42\n  Hello, world!\n");
+}
+
+TEST(Holder, DictionaryHomogeneousString) {
+    Holder h = Holder::create_dict();
+
+    // Add three objects with string keys to the dictionary.
+    h.dict_append(Holder::Type::STRING, "string_key1", Holder::create_string("value1"));
+    h.dict_append(Holder::Type::STRING, "string_key2", Holder::create_string("value2"));
+    h.dict_append(Holder::Type::STRING, "string_key3", Holder::create_string("value3"));
+
+    EXPECT_EQ(h.type(), Holder::Type::DICT);
+
+    EXPECT_EQ(h.signature(), "a{ss}");
+
+    EXPECT_EQ(h.represent(), "Dictionary:\nstring_key1:\n  value1\nstring_key2:\n  value2\nstring_key3:\n  value3\n");
+}
+
+TEST(Holder, DictionaryHeterogeneous) {
+    Holder h = Holder::create_dict();
+
+    // Add three objects with string keys to the dictionary.
+    h.dict_append(Holder::Type::STRING, "string_key1", Holder());
+    h.dict_append(Holder::Type::STRING, "string_key2", Holder());
+    h.dict_append(Holder::Type::STRING, "string_key3", Holder());
+
+    // Add three objects with int keys to the dictionary.
+    h.dict_append(Holder::Type::INT32, static_cast<int32_t>(123), Holder());
+    h.dict_append(Holder::Type::INT32, static_cast<int32_t>(456), Holder());
+    h.dict_append(Holder::Type::INT32, static_cast<int32_t>(789), Holder());
+
+    // Check that all objects with string keys are returned.
+    auto dict_string = h.get_dict_string();
+    EXPECT_EQ(dict_string.size(), 3);
+    EXPECT_EQ(dict_string.count("string_key1"), 1);
+    EXPECT_EQ(dict_string.count("string_key2"), 1);
+    EXPECT_EQ(dict_string.count("string_key3"), 1);
+
+    // Check that all objects with int32 keys are returned.
+    auto dict_int32 = h.get_dict_int32();
+    EXPECT_EQ(dict_int32.size(), 3);
+    EXPECT_EQ(dict_int32.count(123), 1);
+    EXPECT_EQ(dict_int32.count(456), 1);
+    EXPECT_EQ(dict_int32.count(789), 1);
+
+    // TODO: Expand this test to check with all remaining types.
+}
+
+// TODO: Add tests for equality comparison of Holders.