new stuff

added valgrind leak tests to linux workflow

Author: BestITUserEUW

.github/workflows/linux.yaml

@@ -58,4 +58,40 @@ jobs:
           cmake --build build
       - name: Run tests
         run: |
-          ./build/oryx-crt-cpp_tests --success
+          ./build/oryx-crt-cpp_tests --success
+  linux-valgrind:
+    name: "Valgrind leak checks"
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup
+        uses: actions/checkout@v4
+        run: |
+          apt-get update
+          apt-get install -y valgrind
+
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          fetch-depth: 0
+      - name: Export GitHub Actions cache environment variables
+        uses: actions/github-script@v7
+        with:
+          script: |
+            core.exportVariable('ACTIONS_CACHE_URL', process.env.ACTIONS_CACHE_URL || '');
+            core.exportVariable('ACTIONS_RUNTIME_TOKEN', process.env.ACTIONS_RUNTIME_TOKEN || '');
+      - name: Setup ccache
+        uses: hendrikmuhs/ccache-action@v1
+        with:
+          key: "${{ github.job }}-${{ matrix.compiler }}-${{ matrix.compiler-version }}"
+          max-size: "2G"
+      - name: Compile
+        run: |
+          sudo ln -s $(which ccache) /usr/local/bin/$CC
+          sudo ln -s $(which ccache) /usr/local/bin/$CXX
+          $CXX --version
+          cmake -B build -G Ninja -DORYX_CRT_BUILD_TESTS=ON -DCMAKE_BUILD_TYPE=Release
+          cmake --build build
+      - name: Run tests
+        run: |
+          valgrind --leak-check=full --error-exitcode=1 ./build/oryx-crt-cpp_tests

CMakeLists.txt

@@ -19,6 +19,8 @@ else()
     add_library(${PROJECT_NAME} STATIC)
 endif()
 
+add_library("${PROJECT_NAME}::${PROJECT_NAME}" ALIAS ${PROJECT_NAME})
+
 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
     target_compile_options(${PROJECT_NAME} 
         PRIVATE
@@ -59,21 +61,9 @@ target_sources(${PROJECT_NAME}
 
 
 if(ORYX_CRT_BUILD_TESTS)
+    file(GLOB_RECURSE TEST_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/tests/*.cpp")
     set(test_exe ${PROJECT_NAME}_tests)
-    add_executable(${test_exe} 
-        tests/main.cpp 
-        tests/argparse_test.cpp
-        tests/stopwatch_test.cpp
-        tests/error_test.cpp
-        tests/string_split_test.cpp
-        tests/callback_list_test.cpp
-        tests/from_chars_test.cpp
-        tests/is_one_off_test.cpp
-        tests/unique_file_ptr_test.cpp
-        tests/error_group_test.cpp
-        tests/traits_test.cpp
-    )
-
+    add_executable(${test_exe} ${TEST_SOURCES})
     target_link_libraries(${test_exe} PRIVATE ${PROJECT_NAME})
 
     if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")

include/oryx/callback_list.hpp

@@ -17,15 +17,17 @@ template <class... Args>
 class CallbackList {
 public:
     using ID = uint64_t;
+
+    static constexpr ID kIDMax = std::numeric_limits<ID>::max();
     /**
      * @brief Handle to subscription. Can be used to unsubscribe from notifications.
      */
     class Handle {
     public:
         Handle()
-            : id_(0) {}
+            : id_(kIDMax) {}
 
-        auto IsValid() const -> bool { return id_ != 0; }
+        auto IsValid() const -> bool { return id_ != kIDMax; }
         auto id() const { return id_; }
 
     private:
@@ -34,58 +36,61 @@ class CallbackList {
         explicit Handle(ID id)
             : id_(id) {}
 
+        void Reset() { id_ = kIDMax; }
+
         ID id_;
     };
 
     using Callback = std::function<void(Args...)>;
 
     CallbackList() = default;
 
-    auto Subscribe(const Callback& cb) -> Handle {
-        auto handle = CreateHandle();
-        subs_.wlock()->emplace_back(handle.id(), cb);
-        return handle;
-    }
-
     auto Subscribe(Callback&& cb) -> Handle {
-        auto handle = CreateHandle();
-        subs_.wlock()->emplace_back(handle.id(), std::forward<Callback>(cb));
-        return handle;
+        ID id = id_.fetch_add(1, std::memory_order_relaxed);
+        subs_.Apply([&](auto& subs) mutable { subs.emplace_back(id, std::forward<Callback>(cb)); });
+        return Handle(id);
     }
 
     void Unsubscribe(Handle& handle) {
         if (!handle.IsValid()) {
             return;
         }
 
-        auto subs_ptr = subs_.wlock();
-        auto it = std::ranges::find_if(*subs_ptr, [hid = handle.id()](ID id) { return id == hid; }, &Subscriber::id);
-        if (it != subs_ptr->end()) {
-            subs_ptr->erase(it);
-            handle = {};
-        }
+        subs_.Apply([&handle](auto& subs) {
+            auto it = std::ranges::find(subs, handle.id_, &Subscriber::id);
+            if (it != subs.end()) {
+                subs.erase(it);
+                handle.Reset();
+            }
+        });
     }
 
     void Notify(const Args&... args) const {
-        for (auto& sub : *subs_.rlock()) {
-            sub.cb(args...);
-        }
+        subs_.Visit([&](auto& subs) {
+            for (auto& sub : subs) sub.cb(args...);
+        });
     }
 
-    void Clear() { subs_.wlock()->clear(); }
-    auto IsEmpty() const { return subs_.rlock()->empty(); }
-    auto Size() const { return subs_.rlock()->size(); }
+    void Clear() {
+        subs_.Apply([](auto& subs) { subs.clear(); });
+    }
+
+    auto IsEmpty() const {
+        return subs_.Visit([](auto& subs) { return subs.empty(); });
+    }
+
+    auto Size() const {
+        return subs_.Visit([](auto& subs) { return subs.size(); });
+    }
 
 private:
     struct Subscriber {
         ID id;
         Callback cb;
     };
 
-    auto CreateHandle() -> Handle { return Handle(id_.fetch_add(1, std::memory_order_relaxed)); }
-
-    std::atomic<ID> id_{1};
-    synchronized<std::vector<Subscriber>> subs_{};
+    std::atomic<ID> id_{};
+    Synchronized<std::vector<Subscriber>> subs_{};
 };
 
 }  // namespace oryx

include/oryx/lazy_component.hpp

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <concepts>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <type_traits>
+#include <utility>
+#include <cassert>
+
+namespace oryx {
+
+template <class T>
+class LazyComponent {
+public:
+    using FactoryContainer = std::move_only_function<T()>;
+
+    LazyComponent() = default;
+
+    LazyComponent()
+        requires std::is_default_constructible_v<T>
+        : factory_([] { return T(); }) {}
+
+    // Constructor that takes a creator callable
+    template <typename Factory>
+        requires std::invocable<Factory> && std::same_as<std::invoke_result_t<Factory>, T>
+    explicit LazyComponent(Factory&& factory)
+        : factory_(std::forward<Factory>(factory)) {}
+
+    auto operator*() -> T& { return *Get(); }
+    auto operator*() const -> const T& { return *Get(); }
+    auto operator->() -> T* { return Get(); }
+    auto operator->() const -> const T* { return Get(); }
+
+    void Init() { InitOnce(); }
+
+    auto Get() -> T* {
+        InitOnce();
+        return value_.get();
+    }
+
+    auto Get() const -> const T* {
+        InitOnce();
+        return value_.get();
+    }
+
+    auto IsInitialized() const noexcept -> bool { return value_ != nullptr; }
+
+private:
+    void InitOnce() {
+        assert(static_cast<bool>(factory_) && "LazyComponent requires valid factory callable!");
+        std::call_once(created_flag_, [this] { value_ = std::make_unique<T>(std::invoke(factory_)); });
+    }
+
+    std::once_flag created_flag_{};
+    std::move_only_function<T()> factory_{};
+    mutable std::unique_ptr<T> value_{};
+};
+
+template <class Factory>
+LazyComponent(Factory) -> LazyComponent<std::invoke_result_t<Factory>>;
+
+template <class Factory>
+auto MakeLazy(Factory&& factory) {
+    return LazyComponent<std::invoke_result_t<Factory>>(std::forward<Factory>(factory));
+}
+
+}  // namespace oryx