RADCore.h

Go to the documentation of this file.

#ifndef RADCORE_H
#define RADCORE_H
 
#pragma once
#include <RADCore/RADLicenseGate.h>
#include <iostream>
#include <array>
#include <vector>
#include <functional>
#include <queue>
#include <mutex>
#include <map>
#include <chrono>
#include <thread>
#include <atomic>
#include <memory>
#include <algorithm>
#include <cstdint>
#include <sstream>
#include <shared_mutex>
#include <future>
#include <type_traits>
#include <optional>
#include <string>
#include <filesystem>
#include <variant>
#include <condition_variable>
#include <deque>
#include <unordered_map>
#include <exception>
#include <sys/types.h>
 
#if defined(RADLIB_EMBEDDED) && RADLIB_EMBEDDED && !defined(_GLIBCXX_HAS_GTHREADS)
namespace std {
    class mutex {
    public:
        void lock() {
            while (flag_.test_and_set(std::memory_order_acquire)) {}
        }
        void unlock() { flag_.clear(std::memory_order_release); }
    private:
        std::atomic_flag flag_ = ATOMIC_FLAG_INIT;
    };
 
    class condition_variable {
    public:
        void notify_one() {}
        void notify_all() {}
        template<typename Lock, typename Predicate>
        void wait(Lock&, Predicate predicate) {
            while (!predicate()) {
                std::atomic_signal_fence(std::memory_order_seq_cst);
            }
        }
        template<typename Lock, typename Clock, typename Duration, typename Predicate>
        void wait_until(Lock&, const std::chrono::time_point<Clock, Duration>& deadline, Predicate predicate) {
            while (!predicate() && Clock::now() < deadline) {
                std::atomic_signal_fence(std::memory_order_seq_cst);
            }
        }
    };
}
#endif
 
// ==========================================================
// RADICAL COMPUTER TECHNOLOGIES - MACRO SUITE
// ==========================================================
#define RADEvents public
#define RADHandlers public
 
#define RADInfo() RADCore::Internal::LogStream(RADCore::LogLevel::INFO)
#define RADDebug() RADCore::Internal::LogStream(RADCore::LogLevel::DEBUG)
 
#ifndef RADCORE_VERSION_MAJOR
#define RADCORE_VERSION_MAJOR 1
#endif
 
#ifndef RADCORE_VERSION_MINOR
#define RADCORE_VERSION_MINOR 0
#endif
 
#ifndef RADCORE_VERSION_PATCH
#define RADCORE_VERSION_PATCH 0
#endif
 
#define RAD_EVENT(Name, Signature) RADCore::Event<void Signature> Name
 
#define RADCONNECT(Sender, RadEvent, Receiver, Class, RadEventHandler) \
    (Sender).RadEvent.connect(Receiver, &Class::RadEventHandler)
 
#define RADCONNECT_QUEUED(Sender, RadEvent, Loop, Receiver, Class, RadEventHandler) \
    (Sender).RadEvent.connect_queued(Loop, Receiver, &Class::RadEventHandler)
 
#define radtrig(RadEvent, ...) RadEvent.raise(__VA_ARGS__)
 
#define rtrig RADCore::Internal::TriggerHelper() <<
 
namespace RADCore {
 
    constexpr int VersionMajor = RADCORE_VERSION_MAJOR;
    constexpr int VersionMinor = RADCORE_VERSION_MINOR;
    const char* runtimeEdition();
    bool runtimeRequiresLicenseKey();
    const char* runtimeAuditStamp();
    
    class RADObject;
    class EventLoop;
    class EventLoopHandle;
    class Connection;
 
    class RADError {
    public:
        RADError() = default;
        RADError(int code, std::string message)
            : code_(code), message_(std::move(message)) {}
 
        bool hasError() const { return code_ != 0 || !message_.empty(); }
        int code() const { return code_; }
        const std::string& message() const { return message_; }
 
    private:
        int code_ = 0;
        std::string message_;
    };
 
    template<typename T>
    class RADResult {
    public:
        static RADResult success(T value) { return RADResult(std::move(value)); }
        static RADResult failure(RADError error) { return RADResult(std::move(error)); }
 
        bool ok() const { return value_.has_value(); }
        bool hasError() const { return !ok(); }
        T& value() { return *value_; }
        const T& value() const { return *value_; }
        const RADError& error() const { return error_; }
        T valueOr(T defaultValue) const { return value_ ? *value_ : std::move(defaultValue); }
 
    private:
        explicit RADResult(T value) : value_(std::move(value)) {}
        explicit RADResult(RADError error) : error_(std::move(error)) {}
 
        std::optional<T> value_;
        RADError error_;
    };
 
    template<>
    class RADResult<void> {
    public:
        static RADResult success() { return RADResult(); }
        static RADResult failure(RADError error) { return RADResult(std::move(error)); }
        bool ok() const { return !error_.hasError(); }
        bool hasError() const { return error_.hasError(); }
        const RADError& error() const { return error_; }
 
    private:
        RADResult() = default;
        explicit RADResult(RADError error) : error_(std::move(error)) {}
        RADError error_;
    };
 
    template<typename T>
    class RADSpan {
    public:
        RADSpan() = default;
        RADSpan(T* data, size_t size) : data_(data), size_(size) {}
        template<typename Container>
        explicit RADSpan(Container& container) : data_(container.data()), size_(container.size()) {}
 
        T* data() const { return data_; }
        size_t size() const { return size_; }
        bool empty() const { return size_ == 0; }
        T& operator[](size_t index) const { return data_[index]; }
        T* begin() const { return data_; }
        T* end() const { return data_ + size_; }
 
    private:
        T* data_ = nullptr;
        size_t size_ = 0;
    };
 
    using RADByteSpan = RADSpan<uint8_t>;
    using RADConstByteSpan = RADSpan<const uint8_t>;
 
    class RADElapsedTimer {
    public:
        RADElapsedTimer() { restart(); }
        void restart() { start_ = std::chrono::steady_clock::now(); }
        int64_t elapsedNanoseconds() const {
            return std::chrono::duration_cast<std::chrono::nanoseconds>(
                std::chrono::steady_clock::now() - start_).count();
        }
        int64_t elapsedMicroseconds() const { return elapsedNanoseconds() / 1000; }
        int64_t elapsedMilliseconds() const { return elapsedNanoseconds() / 1000000; }
        double elapsedSeconds() const { return static_cast<double>(elapsedNanoseconds()) / 1000000000.0; }
 
    private:
        std::chrono::steady_clock::time_point start_;
    };
 
    class RADDeadlineTimer {
    public:
        RADDeadlineTimer() = default;
        explicit RADDeadlineTimer(int64_t intervalMs)
            : deadline_(std::chrono::steady_clock::now() + std::chrono::milliseconds(intervalMs)),
              valid_(true) {}
        bool isValid() const { return valid_; }
        bool hasExpired() const { return valid_ && std::chrono::steady_clock::now() >= deadline_; }
        int64_t remainingMilliseconds() const {
            if (!valid_) return 0;
            const auto now = std::chrono::steady_clock::now();
            if (now >= deadline_) return 0;
            return std::chrono::duration_cast<std::chrono::milliseconds>(deadline_ - now).count();
        }
 
    private:
        std::chrono::steady_clock::time_point deadline_{};
        bool valid_ = false;
    };
 
    class RADCancellationToken {
    public:
        RADCancellationToken() : cancelled_(std::make_shared<std::atomic_bool>(false)) {}
        bool isCancellationRequested() const {
            return cancelled_ && cancelled_->load(std::memory_order_acquire);
        }
 
    private:
        friend class RADCancellationSource;
        explicit RADCancellationToken(std::shared_ptr<std::atomic_bool> cancelled)
            : cancelled_(std::move(cancelled)) {}
        std::shared_ptr<std::atomic_bool> cancelled_;
    };
 
    class RADCancellationSource {
    public:
        RADCancellationSource() : cancelled_(std::make_shared<std::atomic_bool>(false)) {}
        RADCancellationToken token() const { return RADCancellationToken(cancelled_); }
        void cancel() { cancelled_->store(true, std::memory_order_release); }
        bool isCancellationRequested() const { return cancelled_->load(std::memory_order_acquire); }
 
    private:
        std::shared_ptr<std::atomic_bool> cancelled_;
    };
 
    enum class OpenMode : uint32_t {
        NotOpen = 0,
        ReadOnly = 1 << 0,
        WriteOnly = 1 << 1,
        ReadWrite = (1 << 0) | (1 << 1),
        Append = 1 << 2,
        Truncate = 1 << 3,
        Text = 1 << 4
    };
 
    constexpr OpenMode operator|(OpenMode lhs, OpenMode rhs) {
        return static_cast<OpenMode>(
            static_cast<uint32_t>(lhs) | static_cast<uint32_t>(rhs));
    }
 
    constexpr OpenMode operator&(OpenMode lhs, OpenMode rhs) {
        return static_cast<OpenMode>(
            static_cast<uint32_t>(lhs) & static_cast<uint32_t>(rhs));
    }
 
    constexpr bool hasOpenMode(OpenMode mode, OpenMode flag) {
        return (static_cast<uint32_t>(mode) & static_cast<uint32_t>(flag)) != 0;
    }
 
    enum class ByteOrder {
        LittleEndian,
        BigEndian
    };
 
    enum class DataStreamStatus {
        Ok,
        ReadPastEnd,
        WriteFailed,
        ReadFailed
    };
 
    enum class VariantType {
        Invalid,
        Bool,
        Int64,
        Double,
        String,
        ByteArray
    };
 
    class RADVariant {
    public:
        RADVariant();
        RADVariant(bool value);
        RADVariant(int value);
        RADVariant(int64_t value);
        RADVariant(double value);
        RADVariant(const char* value);
        RADVariant(std::string value);
        RADVariant(std::vector<uint8_t> value);
 
        VariantType type() const;
        bool isValid() const;
        bool toBool(bool defaultValue = false) const;
        int64_t toInt64(int64_t defaultValue = 0) const;
        double toDouble(double defaultValue = 0.0) const;
        std::string toString(const std::string& defaultValue = {}) const;
        std::vector<uint8_t> toByteArray() const;
 
    private:
        using Storage = std::variant<std::monostate, bool, int64_t, double, std::string, std::vector<uint8_t>>;
        Storage data_;
    };
 
    class RADDateTime {
    public:
        RADDateTime();
        explicit RADDateTime(int64_t unixMilliseconds);
 
        static RADDateTime nowUtc();
        static RADDateTime fromUnixMilliseconds(int64_t unixMilliseconds);
        static std::optional<RADDateTime> fromIsoString(const std::string& isoString);
 
        int64_t toUnixMilliseconds() const;
        std::string toIsoString() const;
        bool isValid() const;
 
    private:
        int64_t unixMilliseconds_ = 0;
        bool valid_ = false;
    };
 
    class RADUuid {
    public:
        RADUuid();
        explicit RADUuid(std::array<uint8_t, 16> bytes);
 
        static RADUuid createUuid();
        static std::optional<RADUuid> fromString(const std::string& text);
 
        std::string toString() const;
        bool isNull() const;
        const std::array<uint8_t, 16>& bytes() const;
 
    private:
        std::array<uint8_t, 16> bytes_{};
    };
 
    class RADUrl {
    public:
        RADUrl() = default;
        explicit RADUrl(std::string url);
 
        static std::optional<RADUrl> parse(const std::string& url);
 
        bool isValid() const;
        const std::string& scheme() const;
        const std::string& host() const;
        uint16_t port(uint16_t defaultPort = 0) const;
        const std::string& path() const;
        const std::string& query() const;
        const std::string& fragment() const;
        std::string toString() const;
 
    private:
        bool valid_ = false;
        std::string scheme_;
        std::string host_;
        uint16_t port_ = 0;
        std::string path_ = "/";
        std::string query_;
        std::string fragment_;
    };
 
    enum class JsonType {
        Null,
        Bool,
        Number,
        String,
        Array,
        Object
    };
 
    class RADJsonValue {
    public:
        RADJsonValue();
        RADJsonValue(std::nullptr_t);
        RADJsonValue(bool value);
        RADJsonValue(int value);
        RADJsonValue(int64_t value);
        RADJsonValue(double value);
        RADJsonValue(const char* value);
        RADJsonValue(std::string value);
        RADJsonValue(const RADJsonValue& other);
        RADJsonValue(RADJsonValue&& other) noexcept = default;
        RADJsonValue& operator=(const RADJsonValue& other);
        RADJsonValue& operator=(RADJsonValue&& other) noexcept = default;
 
        static RADJsonValue array();
        static RADJsonValue object();
 
        JsonType type() const;
        bool isNull() const;
        bool isBool() const;
        bool isNumber() const;
        bool isString() const;
        bool isArray() const;
        bool isObject() const;
 
        bool toBool(bool defaultValue = false) const;
        double toNumber(double defaultValue = 0.0) const;
        int toInt(int defaultValue = 0) const;
        int64_t toInt64(int64_t defaultValue = 0) const;
        std::string toString(const std::string& defaultValue = {}) const;
 
        size_t size() const;
        bool contains(const std::string& key) const;
        std::vector<std::string> keys() const;
        void append(RADJsonValue value);
        void remove(const std::string& key);
 
        RADJsonValue& operator[](const std::string& key);
        const RADJsonValue& operator[](const std::string& key) const;
        RADJsonValue& operator[](size_t index);
        const RADJsonValue& operator[](size_t index) const;
 
        std::string toJson(bool pretty = false, int indent = 0) const;
 
    private:
        struct ArrayData;
        struct ObjectData;
 
        using Storage = std::variant<
            std::nullptr_t,
            bool,
            int64_t,
            double,
            std::string,
            std::shared_ptr<ArrayData>,
            std::shared_ptr<ObjectData>>;
 
        void ensureArray();
        void ensureObject();
        const ArrayData* arrayData() const;
        ArrayData* arrayData();
        const ObjectData* objectData() const;
        ObjectData* objectData();
        static Storage cloneStorage(const Storage& storage);
        static const RADJsonValue& nullValue();
 
        Storage data_;
    };
 
    class RADJsonDocument {
    public:
        RADJsonDocument();
        explicit RADJsonDocument(RADJsonValue root);
 
        static std::optional<RADJsonDocument> fromJson(const std::string& json, std::string* error = nullptr);
        static std::optional<RADJsonDocument> fromFile(const std::string& path, std::string* error = nullptr);
 
        const RADJsonValue& root() const;
        RADJsonValue& root();
        std::string toJson(bool pretty = false) const;
        bool toFile(const std::string& path, bool pretty = true, std::string* error = nullptr) const;
 
    private:
        RADJsonValue root_;
    };
 
    class RADSettings {
    public:
        explicit RADSettings(std::string fileName);
 
        const std::string& fileName() const;
        bool load(std::string* error = nullptr);
        bool save(std::string* error = nullptr) const;
        bool contains(const std::string& key) const;
        RADJsonValue value(const std::string& key, RADJsonValue defaultValue = {}) const;
        void setValue(const std::string& key, RADJsonValue value);
        void remove(const std::string& key);
        void clear();
 
    private:
        std::string fileName_;
        RADJsonValue root_;
    };
 
    namespace FileSystem {
        enum class StandardPath {
            Home,
            Desktop,
            Documents,
            Downloads,
            Config,
            Data,
            Cache,
            Temp,
            Executable,
            Current
        };
 
        enum class DirectoryEntryType {
            Unknown,
            File,
            Directory,
            Symlink
        };
 
        struct DirectoryEntry {
            std::string path;
            std::string name;
            DirectoryEntryType type = DirectoryEntryType::Unknown;
            uintmax_t size = 0;
            int64_t modifiedUnixMs = 0;
        };
 
        bool exists(const std::string& path);
        bool isFile(const std::string& path);
        bool isDirectory(const std::string& path);
        bool createDirectories(const std::string& path);
        bool remove(const std::string& path);
        bool copyFile(const std::string& source, const std::string& destination, bool overwrite = true);
        std::string currentPath();
        std::string tempDirectoryPath();
        std::string standardPath(StandardPath path);
        std::string fileName(const std::string& path);
        std::string extension(const std::string& path);
        std::string parentPath(const std::string& path);
        std::vector<DirectoryEntry> listEntries(const std::string& path, bool recursive = false);
        std::vector<std::string> listDirectory(const std::string& path);
        std::string mimeTypeForFile(const std::string& path);
        std::optional<std::string> readTextFile(const std::string& path);
        bool writeTextFile(const std::string& path, const std::string& text);
    }
 
    class RADTemporaryDirectory {
    public:
        explicit RADTemporaryDirectory(std::string prefix = "radlib");
        ~RADTemporaryDirectory();
 
        RADTemporaryDirectory(const RADTemporaryDirectory&) = delete;
        RADTemporaryDirectory& operator=(const RADTemporaryDirectory&) = delete;
        RADTemporaryDirectory(RADTemporaryDirectory&& other) noexcept;
        RADTemporaryDirectory& operator=(RADTemporaryDirectory&& other) noexcept;
 
        bool isValid() const;
        const std::string& path() const;
        void setAutoRemove(bool enabled);
        bool autoRemove() const;
        bool remove();
 
    private:
        std::string path_;
        bool autoRemove_ = true;
    };
 
    class RADTemporaryFile {
    public:
        explicit RADTemporaryFile(std::string prefix = "radlib");
        ~RADTemporaryFile();
 
        RADTemporaryFile(const RADTemporaryFile&) = delete;
        RADTemporaryFile& operator=(const RADTemporaryFile&) = delete;
        RADTemporaryFile(RADTemporaryFile&& other) noexcept;
        RADTemporaryFile& operator=(RADTemporaryFile&& other) noexcept;
 
        bool isValid() const;
        const std::string& fileName() const;
        int fd() const;
        void setAutoRemove(bool enabled);
        bool autoRemove() const;
        bool remove();
 
    private:
        std::string fileName_;
        int fd_ = -1;
        bool autoRemove_ = true;
    };
 
    class RADLockFile {
    public:
        explicit RADLockFile(std::string fileName);
        ~RADLockFile();
 
        RADLockFile(const RADLockFile&) = delete;
        RADLockFile& operator=(const RADLockFile&) = delete;
 
        bool tryLock();
        void unlock();
        bool isLocked() const;
        const std::string& fileName() const;
 
    private:
        std::string fileName_;
        int fd_ = -1;
    };
 
    enum class ProcessState {
        NotRunning,
        Running,
        Finished,
        FailedToStart
    };
 
    struct ThreadAffinity {
        std::thread::id threadId;
        EventLoop* eventLoop;
    };
    
    template<typename Signature> class Event;
 
    namespace Internal {
        template<typename T> struct ExtractArgs;
        template<typename Ret, typename... Args>
        struct ExtractArgs<Ret(*)(Args...)> { using type = void(Args...); };
 
        template<typename... Args> struct EventBinder;
        struct TriggerHelper;
    }
 
    enum class LoopStrategy { RADEVENT_LOCK, RADEVENT_NOLOCK };
    constexpr LoopStrategy RADEVENT_LOCK = LoopStrategy::RADEVENT_LOCK;
    constexpr LoopStrategy RADEVENT_NOLOCK = LoopStrategy::RADEVENT_NOLOCK;
    enum class Priority : int { LOW = 0, NORMAL = 1, HIGH = 2 };
 
    struct ConnectionRecord {
        size_t connectionId;
        std::function<void()> disconnectCallback;
    };
 
    class Connection {
    public:
        struct State {
            std::atomic_bool connected{false};
            std::function<void()> disconnectCallback;
        };
 
        Connection() = default;
 
        void disconnect();
        bool isConnected() const;
 
    private:
        explicit Connection(std::shared_ptr<State> state);
        static Connection create(std::function<void()> disconnectCallback);
 
        std::shared_ptr<State> state_;
 
        template<typename Signature> friend class Event;
    };
 
    class RADObject {
    public:
        RADObject();
        virtual ~RADObject(); 
        void registerLink(const ConnectionRecord& record);
        
        std::thread::id threadId() const;
        EventLoop* associatedEventLoop() const;
        ThreadAffinity threadAffinity() const;
        std::weak_ptr<void> lifetimeToken() const;
        void moveToThread(std::thread::id tId, EventLoop* loop = nullptr);
    private:
        struct Impl;
        std::unique_ptr<Impl> pImpl;
    };
 
    class EventLoop {
    public:
        using Task = std::function<void()>;
        EventLoop(LoopStrategy strategy = RADEVENT_LOCK); 
        ~EventLoop(); 
        
        void post(Priority priority, Task task);
        void post(Task task);
        bool processEvents();
        void exec();
        void quit();
        bool isEventThread() const;
        EventLoopHandle handle() const;
        bool postDelayed(int delayMs, Task task);
        
        template<typename F, typename... Args>
        void post(Priority priority, F&& f, Args&&... args) {
            auto boundTask = [f = std::forward<F>(f), ...args = std::forward<Args>(args)]() mutable {
                f(std::forward<Args>(args)...);
            };
            post(priority, Task(boundTask));
        }
 
        template<typename F, typename... Args>
        void post(F&& f, Args&&... args) {
            auto boundTask = [f = std::forward<F>(f), ...args = std::forward<Args>(args)]() mutable {
                f(std::forward<Args>(args)...);
            };
            post(Task(boundTask));
        }
 
    private:
        struct Impl;
        friend class EventLoopHandle;
        std::shared_ptr<Impl> pImpl;
    };
 
    class EventLoopHandle {
    public:
        EventLoopHandle() = default;
        bool isValid() const;
        bool post(Priority priority, EventLoop::Task task) const;
        bool post(EventLoop::Task task) const;
        bool postDelayed(int delayMs, EventLoop::Task task) const;
 
    private:
        friend class EventLoop;
        explicit EventLoopHandle(std::weak_ptr<EventLoop::Impl> impl);
        std::weak_ptr<EventLoop::Impl> impl_;
    };
 
    void singleShot(int intervalMs, EventLoop& targetLoop, EventLoop::Task task);
 
    template<typename F>
    void invoke(EventLoop& loop, F&& task) {
        loop.post(std::forward<F>(task));
    }
 
    template<typename F>
    auto invokeBlocking(EventLoop& loop, F&& task) -> std::invoke_result_t<F> {
        using ReturnType = std::invoke_result_t<F>;
 
        if (loop.isEventThread()) {
            if constexpr (std::is_void_v<ReturnType>) {
                std::forward<F>(task)();
                return;
            } else {
                return std::forward<F>(task)();
            }
        }
 
        auto promise = std::make_shared<std::promise<ReturnType>>();
        auto future = promise->get_future();
        auto taskPtr = std::make_shared<std::decay_t<F>>(std::forward<F>(task));
 
        loop.post([promise, taskPtr]() mutable {
            try {
                if constexpr (std::is_void_v<ReturnType>) {
                    (*taskPtr)();
                    promise->set_value();
                } else {
                    promise->set_value((*taskPtr)());
                }
            } catch (...) {
                promise->set_exception(std::current_exception());
            }
        });
 
        if constexpr (std::is_void_v<ReturnType>) {
            future.get();
            return;
        } else {
            return future.get();
        }
    }
 
    class EventBackend {
    public:
        using RawTask = std::function<void()>;
        
        void addRawHandler(size_t id, RawTask task);
        void removeRawHandler(size_t id);
        void invokeAll();
    private:
        struct BackendSlot { size_t id; RawTask task; };
        std::vector<BackendSlot> rawHandlers_; 
        std::mutex backendMutex_;
    };
 
    template<typename... Args>
    class Event<void(Args...)> {
    public:
        struct LiveHandler {
            size_t id;
            std::function<void(Args...)> dispatch;
            std::shared_ptr<Connection::State> connectionState;
        };
 
        Event() : aliveToken_(std::make_shared<std::atomic_bool>(true)) {}
        
        ~Event() {
            // Explicitly invalidate our token to instantly tell all bound receivers that this event is dead!
            aliveToken_->store(false, std::memory_order_release);
            std::lock_guard<std::mutex> lock(eventMutex_);
            for (const auto& handler : handlers_) {
                if (handler.connectionState) {
                    handler.connectionState->connected.store(false, std::memory_order_release);
                }
            }
        }
 
        template<typename T>
        Connection connect(T* receiver, void(T::*memberFunc)(Args...)) {
            size_t uniqueId = generateUniqueId();
            RADObject* baseReceiver = static_cast<RADObject*>(receiver);
            
            auto receiverToken = baseReceiver->lifetimeToken();
            auto dispatchBridge = [receiverToken, receiver, memberFunc, baseReceiver](Args... args) {
                auto receiverLife = receiverToken.lock();
                if (!receiverLife) return;
 
                const ThreadAffinity affinity = baseReceiver->threadAffinity();
                if (affinity.threadId == std::this_thread::get_id()) {
                    (receiver->*memberFunc)(args...);
                } else {
                    EventLoop* targetLoop = affinity.eventLoop;
                    if (targetLoop) {
                        targetLoop->post([receiverToken, receiver, memberFunc, ...args = std::forward<Args>(args)]() mutable {
                            auto queuedReceiverLife = receiverToken.lock();
                            if (!queuedReceiverLife) return;
                            (receiver->*memberFunc)(std::forward<Args>(args)...);
                        });
                    } else {
                        (receiver->*memberFunc)(args...); 
                    }
                }
            };
 
            backend_.addRawHandler(uniqueId, [this]() {});
 
            auto token = aliveToken_;
            Connection connection = Connection::create([this, uniqueId, token]() {
                if (token->load(std::memory_order_acquire)) {
                    this->disconnect(uniqueId);
                }
            });
 
            {
                std::lock_guard<std::mutex> lock(eventMutex_);
                handlers_.push_back({
                    uniqueId,
                    [dispatchBridge](Args... args) { dispatchBridge(args...); },
                    connection.state_
                });
            }
 
            // Capture a copy of our aliveToken inside the registration block!
            baseReceiver->registerLink({ uniqueId, [connection]() mutable {
                connection.disconnect();
            }});
 
            return connection;
        }
 
        template<typename T>
        Connection connect_queued(EventLoop& loop, T* receiver, void(T::*memberFunc)(Args...)) {
            size_t uniqueId = generateUniqueId();
            RADObject* baseObject = static_cast<RADObject*>(receiver);
            auto receiverToken = baseObject->lifetimeToken();
            
            auto cb = [&loop, receiverToken, receiver, memberFunc](Args... args) {
                loop.post([receiverToken, receiver, memberFunc, ...args = std::forward<Args>(args)]() mutable {
                    auto receiverLife = receiverToken.lock();
                    if (!receiverLife) return;
                    (receiver->*memberFunc)(std::forward<Args>(args)...);
                });
            };
 
            backend_.addRawHandler(uniqueId, [cb]() {});
 
            auto token = aliveToken_;
            Connection connection = Connection::create([&loop, this, uniqueId, token]() {
                if (token->load(std::memory_order_acquire)) {
                    loop.post(Priority::HIGH, [this, uniqueId]() { this->disconnect(uniqueId); });
                }
            });
 
            {
                std::lock_guard<std::mutex> lock(eventMutex_);
                handlers_.push_back({
                    uniqueId,
                    [cb](Args... args) { cb(args...); },
                    connection.state_
                });
            }
 
            baseObject->registerLink({ uniqueId, [connection]() mutable {
                connection.disconnect();
            }});
 
            return connection;
        }
 
        void disconnect(size_t targetId) { 
            std::lock_guard<std::mutex> lock(eventMutex_);
            for (const auto& handler : handlers_) {
                if (handler.id == targetId && handler.connectionState) {
                    handler.connectionState->connected.store(false, std::memory_order_release);
                }
            }
            handlers_.erase(std::remove_if(handlers_.begin(), handlers_.end(), [targetId](const LiveHandler& handler) {
                return handler.id == targetId;
            }), handlers_.end());
            backend_.removeRawHandler(targetId);
        }
        
        void raise(Args... args) {
            std::vector<std::function<void(Args...)>> localHandlers;
            {
                std::lock_guard<std::mutex> lock(eventMutex_);
                localHandlers.reserve(handlers_.size());
                for (const auto& handler : handlers_) {
                    localHandlers.push_back(handler.dispatch);
                }
            }
            for (const auto& handler : localHandlers) {
                if (handler) handler(args...);
            }
            backend_.invokeAll(); 
        }
 
    private:
        size_t generateUniqueId() { static std::atomic<size_t> s_counter{0}; return s_counter++; }
        std::vector<LiveHandler> handlers_;
        std::mutex eventMutex_;
        EventBackend backend_; 
        std::shared_ptr<std::atomic_bool> aliveToken_; // Token tracking emitter lifespan state parameters
    };
 
    class RADIODevice : public RADObject {
    public:
        RADEvents:
            RAD_EVENT(readyRead, ());
            RAD_EVENT(bytesWritten, (size_t));
            RAD_EVENT(errorOccurred, (std::string));
 
        virtual ~RADIODevice() = default;
 
        virtual bool open(OpenMode mode) = 0;
        virtual void close() = 0;
        virtual bool isOpen() const = 0;
        virtual ssize_t readData(void* buffer, size_t maxBytes) = 0;
        virtual ssize_t writeData(const void* data, size_t size) = 0;
 
        std::vector<uint8_t> read(size_t maxBytes);
        std::vector<uint8_t> readAll(size_t chunkSize = 8192);
        ssize_t write(const std::vector<uint8_t>& data);
        ssize_t write(const std::string& text);
    };
 
    class RADBuffer : public RADIODevice {
    public:
        RADBuffer();
        explicit RADBuffer(std::vector<uint8_t> data);
        ~RADBuffer() override;
 
        bool open(OpenMode mode) override;
        void close() override;
        bool isOpen() const override;
        ssize_t readData(void* buffer, size_t maxBytes) override;
        ssize_t writeData(const void* data, size_t size) override;
 
        bool seek(size_t position);
        size_t position() const;
        size_t size() const;
        const std::vector<uint8_t>& data() const;
        void clear();
 
    private:
        struct Impl;
        std::unique_ptr<Impl> pImpl_;
    };
 
    class RADFile : public RADIODevice {
    public:
        RADFile();
        explicit RADFile(std::string fileName);
        ~RADFile() override;
 
        void setFileName(std::string fileName);
        const std::string& fileName() const;
 
        bool open(OpenMode mode) override;
        void close() override;
        bool isOpen() const override;
        ssize_t readData(void* buffer, size_t maxBytes) override;
        ssize_t writeData(const void* data, size_t size) override;
 
        bool seek(size_t position);
        size_t position() const;
        size_t size() const;
 
    private:
        struct Impl;
        std::unique_ptr<Impl> pImpl_;
    };
 
    class RADDataStream {
    public:
        explicit RADDataStream(RADIODevice& device);
 
        void setByteOrder(ByteOrder byteOrder);
        ByteOrder byteOrder() const;
        DataStreamStatus status() const;
        bool ok() const;
        void resetStatus();
 
        RADDataStream& operator<<(uint8_t value);
        RADDataStream& operator<<(uint16_t value);
        RADDataStream& operator<<(uint32_t value);
        RADDataStream& operator<<(uint64_t value);
        RADDataStream& operator<<(int8_t value);
        RADDataStream& operator<<(int16_t value);
        RADDataStream& operator<<(int32_t value);
        RADDataStream& operator<<(int64_t value);
        RADDataStream& operator<<(float value);
        RADDataStream& operator<<(double value);
        RADDataStream& operator<<(const std::string& value);
        RADDataStream& operator<<(const std::vector<uint8_t>& value);
 
        RADDataStream& operator>>(uint8_t& value);
        RADDataStream& operator>>(uint16_t& value);
        RADDataStream& operator>>(uint32_t& value);
        RADDataStream& operator>>(uint64_t& value);
        RADDataStream& operator>>(int8_t& value);
        RADDataStream& operator>>(int16_t& value);
        RADDataStream& operator>>(int32_t& value);
        RADDataStream& operator>>(int64_t& value);
        RADDataStream& operator>>(float& value);
        RADDataStream& operator>>(double& value);
        RADDataStream& operator>>(std::string& value);
        RADDataStream& operator>>(std::vector<uint8_t>& value);
 
    private:
        bool writeRaw(const void* data, size_t size);
        bool readRaw(void* data, size_t size);
        template<typename T>
        bool writeIntegral(T value);
        template<typename T>
        bool readIntegral(T& value);
 
        RADIODevice& device_;
        ByteOrder byteOrder_ = ByteOrder::LittleEndian;
        DataStreamStatus status_ = DataStreamStatus::Ok;
    };
 
    enum class FileSystemEvent {
        Created,
        Modified,
        Removed,
        Moved,
        Overflow,
        WatchLost,
        Unknown
    };
 
    class RADFileSystemWatcher : public RADObject {
    public:
        RADEvents:
            RAD_EVENT(changed, (std::string, FileSystemEvent));
            RAD_EVENT(errorOccurred, (std::string));
 
        explicit RADFileSystemWatcher(EventLoop& loop);
        ~RADFileSystemWatcher() override;
 
        bool addPath(const std::string& path);
        bool addPath(const std::string& path, bool recursive);
        void removePath(const std::string& path);
        void clear();
        std::vector<std::string> paths() const;
 
    private:
        struct Impl;
        std::shared_ptr<Impl> pImpl_;
    };
 
#if !defined(RADLIB_EMBEDDED) || !RADLIB_EMBEDDED
    class RADFuture {
    public:
        RADFuture();
        explicit RADFuture(std::shared_ptr<std::shared_future<RADVariant>> future);
 
        bool isValid() const;
        bool isFinished() const;
        RADVariant result(RADVariant defaultValue = {}) const;
        void wait() const;
 
    private:
        std::shared_ptr<std::shared_future<RADVariant>> future_;
    };
 
    template<typename T>
    class RADFutureT {
    public:
        RADFutureT() = default;
        explicit RADFutureT(std::shared_ptr<std::shared_future<T>> future)
            : future_(std::move(future)) {}
 
        bool isValid() const { return future_ && future_->valid(); }
        bool isFinished() const {
            return isValid() && future_->wait_for(std::chrono::seconds(0)) == std::future_status::ready;
        }
        void wait() const { if (isValid()) future_->wait(); }
        T result() const { return future_->get(); }
        T resultOr(T defaultValue) const {
            if (!isFinished()) return defaultValue;
            try { return future_->get(); } catch (...) { return defaultValue; }
        }
 
        template<typename F>
        void then(EventLoop& loop, F&& continuation) const {
            auto future = future_;
            auto handle = loop.handle();
            auto fn = std::make_shared<std::decay_t<F>>(std::forward<F>(continuation));
            std::thread([future, handle, fn]() mutable {
                if (!future) return;
                try {
                    T value = future->get();
                    handle.post([fn, value = std::move(value)]() mutable { (*fn)(std::move(value)); });
                } catch (...) {
                    handle.post([fn]() mutable { (*fn)(T{}); });
                }
            }).detach();
        }
 
    private:
        std::shared_ptr<std::shared_future<T>> future_;
    };
 
    template<>
    class RADFutureT<void> {
    public:
        RADFutureT() = default;
        explicit RADFutureT(std::shared_ptr<std::shared_future<void>> future)
            : future_(std::move(future)) {}
        bool isValid() const { return future_ && future_->valid(); }
        bool isFinished() const {
            return isValid() && future_->wait_for(std::chrono::seconds(0)) == std::future_status::ready;
        }
        void wait() const { if (isValid()) future_->wait(); }
        void result() const { if (future_) future_->get(); }
        template<typename F>
        void then(EventLoop& loop, F&& continuation) const {
            auto future = future_;
            auto handle = loop.handle();
            auto fn = std::make_shared<std::decay_t<F>>(std::forward<F>(continuation));
            std::thread([future, handle, fn]() mutable {
                if (future) {
                    try { future->get(); } catch (...) {}
                }
                handle.post([fn]() mutable { (*fn)(); });
            }).detach();
        }
 
    private:
        std::shared_ptr<std::shared_future<void>> future_;
    };
 
    template<typename T>
    class RADPromise {
    public:
        RADPromise()
            : promise_(std::make_shared<std::promise<T>>()),
              future_(std::make_shared<std::shared_future<T>>(promise_->get_future().share())) {}
        RADFutureT<T> future() const { return RADFutureT<T>(future_); }
        void setValue(T value) { promise_->set_value(std::move(value)); }
        void setException(std::exception_ptr error) { promise_->set_exception(error); }
 
    private:
        std::shared_ptr<std::promise<T>> promise_;
        std::shared_ptr<std::shared_future<T>> future_;
    };
 
    template<>
    class RADPromise<void> {
    public:
        RADPromise()
            : promise_(std::make_shared<std::promise<void>>()),
              future_(std::make_shared<std::shared_future<void>>(promise_->get_future().share())) {}
        RADFutureT<void> future() const { return RADFutureT<void>(future_); }
        void setValue() { promise_->set_value(); }
        void setException(std::exception_ptr error) { promise_->set_exception(error); }
 
    private:
        std::shared_ptr<std::promise<void>> promise_;
        std::shared_ptr<std::shared_future<void>> future_;
    };
 
    class RADThreadPool : public RADObject {
    public:
        explicit RADThreadPool(size_t threadCount = std::thread::hardware_concurrency());
        ~RADThreadPool() override;
 
        RADFuture submit(EventLoop& completionLoop, std::function<RADVariant()> task);
        template<typename F>
        auto submitTyped(EventLoop& completionLoop, F&& task) -> RADFutureT<std::invoke_result_t<F>> {
            using ReturnType = std::invoke_result_t<F>;
            auto promise = std::make_shared<std::promise<ReturnType>>();
            auto future = std::make_shared<std::shared_future<ReturnType>>(promise->get_future().share());
            auto taskPtr = std::make_shared<std::decay_t<F>>(std::forward<F>(task));
            enqueue([promise, taskPtr, &completionLoop]() mutable {
                try {
                    if constexpr (std::is_void_v<ReturnType>) {
                        (*taskPtr)();
                        promise->set_value();
                    } else {
                        promise->set_value((*taskPtr)());
                    }
                    completionLoop.post([] {});
                } catch (...) {
                    promise->set_exception(std::current_exception());
                    completionLoop.post([] {});
                }
            });
            return RADFutureT<ReturnType>(future);
        }
        template<typename F>
        auto submitCancellable(EventLoop& completionLoop, RADCancellationToken token, F&& task)
            -> RADFutureT<std::invoke_result_t<F, RADCancellationToken>> {
            using ReturnType = std::invoke_result_t<F, RADCancellationToken>;
            auto promise = std::make_shared<std::promise<ReturnType>>();
            auto future = std::make_shared<std::shared_future<ReturnType>>(promise->get_future().share());
            auto taskPtr = std::make_shared<std::decay_t<F>>(std::forward<F>(task));
            enqueue([promise, taskPtr, token, &completionLoop]() mutable {
                try {
                    if constexpr (std::is_void_v<ReturnType>) {
                        (*taskPtr)(token);
                        promise->set_value();
                    } else {
                        promise->set_value((*taskPtr)(token));
                    }
                    completionLoop.post([] {});
                } catch (...) {
                    promise->set_exception(std::current_exception());
                    completionLoop.post([] {});
                }
            });
            return RADFutureT<ReturnType>(future);
        }
        void waitForDone();
        size_t threadCount() const;
 
    private:
        void enqueue(std::function<void()> task);
        struct Impl;
        std::shared_ptr<Impl> pImpl_;
    };
#endif
 
    class RADAbstractItemModel : public RADObject {
    public:
        RADEvents:
            RAD_EVENT(modelReset, ());
            RAD_EVENT(dataChanged, (size_t, size_t));
            RAD_EVENT(rowsInserted, (size_t, size_t));
            RAD_EVENT(rowsRemoved, (size_t, size_t));
 
        virtual ~RADAbstractItemModel() = default;
        virtual size_t rowCount() const = 0;
        virtual size_t columnCount() const = 0;
        virtual RADVariant data(size_t row, size_t column = 0) const = 0;
    };
 
    class RADStringListModel : public RADAbstractItemModel {
    public:
        size_t rowCount() const override;
        size_t columnCount() const override;
        RADVariant data(size_t row, size_t column = 0) const override;
 
        void append(std::string value);
        void set(size_t row, std::string value);
        void remove(size_t row);
        void clear();
        const std::vector<std::string>& values() const;
 
    private:
        std::vector<std::string> values_;
    };
 
    class RADProcess : public RADObject {
    public:
        RADEvents:
            RAD_EVENT(started, ());
            RAD_EVENT(finished, (int));
            RAD_EVENT(errorOccurred, (std::string));
 
        RADProcess();
        ~RADProcess() override;
 
        bool start(const std::string& program, const std::vector<std::string>& arguments = {});
        bool waitForFinished(int timeoutMs = -1);
        void kill();
 
        ProcessState state() const;
        int exitCode() const;
        std::string readAllStandardOutput() const;
        std::string readAllStandardError() const;
 
    private:
        struct Impl;
        std::unique_ptr<Impl> pImpl_;
    };
 
    class RADPtyProcess : public RADObject {
    public:
        RADEvents:
            RAD_EVENT(started, ());
            RAD_EVENT(finished, (int));
            RAD_EVENT(errorOccurred, (std::string));
 
        RADPtyProcess();
        ~RADPtyProcess() override;
 
        bool start(const std::string& program = {}, const std::vector<std::string>& arguments = {},
            uint16_t rows = 30, uint16_t columns = 120);
        bool waitForFinished(int timeoutMs = -1);
        void kill();
        void close();
 
        ssize_t readData(void* buffer, size_t maxBytes);
        ssize_t writeData(const void* data, size_t size);
        ssize_t write(const std::string& text);
        bool resizeTerminal(uint16_t rows, uint16_t columns);
 
        ProcessState state() const;
        int exitCode() const;
 
    private:
        struct Impl;
        std::unique_ptr<Impl> pImpl_;
    };
 
    class Timer : public RADObject {
    public:
        RADEvents:
            RAD_EVENT(timeout, ()); 
            RAD_EVENT(errorOccurred, (std::string));
 
        Timer();
        ~Timer();
 
        void start(int intervalMs, EventLoop& targetLoop);
        void start(EventLoop& targetLoop);
        void stop();
        void setInterval(int intervalMs);
        int interval() const;
        bool isActive() const;
 
        static void singleShot(int intervalMs, EventLoop& targetLoop, EventLoop::Task task);
 
    private:
        std::atomic<bool> active_; 
        std::thread timerThread_;
        std::atomic<int> timerFd_{-1}; 
        std::atomic<int> stopFd_{-1};
        std::atomic<int> intervalMs_{0};
    };
 
    class RADThread : public RADObject {
    public:
        RADEvents:
            RAD_EVENT(started, ());  
            RAD_EVENT(finished, ()); 
 
    public:
        RADThread();
        virtual ~RADThread(); 
 
        void start(LoopStrategy strategy = LoopStrategy::RADEVENT_LOCK);
        void quit();
        void wait();
        EventLoop& eventLoop();
        bool isRunning() const;
        protected:
            virtual void run();
        private:
            struct Impl;
            std::unique_ptr<Impl> pImpl;
        };
 
    namespace Internal {
        template<typename... Args>
        struct EventBinder {Event<void(Args...)>& targetEvent;
            EventBinder(Event<void(Args...)>& ev) : targetEvent(ev) {}
            void operator()(Args... args) { 
                targetEvent.raise(std::forward(args)...); 
            }
        };
        struct TriggerHelper {
            void operator<<(Event<void()>& targetEvent) { targetEvent.raise(); }
            template<typename... Args>EventBinder<Args...> operator<<(Event<void(Args...)>& targetEvent) { 
                return EventBinder<Args...>(targetEvent); 
            }
        };
    }
 
    enum class LogLevel { INFO, DEBUG };
 
    void initLogger();
    void shutdownLogger();
 
    namespace Internal {
        class LogStream {
        public:
            LogStream(LogLevel level);
            ~LogStream(); // Flushes the accumulated string buffer to the background thread on destruction
 
            template<typename T>
            LogStream& operator<<(const T& value) {
                stream_ << value;
                return *this;
            }
 
            LogStream& operator<<(std::ostream& (*manip)(std::ostream&)) {
                stream_ << manip;
                return *this;
            }
 
        private:
            LogLevel level_;
            std::stringstream stream_;
        };
    }
} // namespace RADCore
#endif