callback_manager.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <cstdint>
#include <functional>
#include <mutex>
#include <system_error>
#include <tuple>
#include <utility>
#include <vector>
 
namespace kcenon::network::utils
{
 
    template<typename... CallbackTypes>
    class callback_manager
    {
    public:
        callback_manager() = default;
 
        ~callback_manager() = default;
 
        // Non-copyable, movable
        callback_manager(const callback_manager&) = delete;
        callback_manager& operator=(const callback_manager&) = delete;
        callback_manager(callback_manager&&) noexcept = default;
        callback_manager& operator=(callback_manager&&) noexcept = default;
 
        template<std::size_t Index>
        auto set(std::tuple_element_t<Index, std::tuple<CallbackTypes...>> callback) -> void
        {
            std::lock_guard lock(mutex_);
            std::get<Index>(callbacks_) = std::move(callback);
        }
 
        template<typename T>
        auto set(T callback) -> void
        {
            std::lock_guard lock(mutex_);
            std::get<T>(callbacks_) = std::move(callback);
        }
 
        template<std::size_t Index>
        [[nodiscard]] auto get() const -> std::tuple_element_t<Index, std::tuple<CallbackTypes...>>
        {
            std::lock_guard lock(mutex_);
            return std::get<Index>(callbacks_);
        }
 
        template<typename T>
        [[nodiscard]] auto get() const -> T
        {
            std::lock_guard lock(mutex_);
            return std::get<T>(callbacks_);
        }
 
        template<std::size_t Index, typename... Args>
        auto invoke(Args&&... args) -> void
        {
            auto callback = get<Index>();
            if (callback)
            {
                callback(std::forward<Args>(args)...);
            }
        }
 
        template<typename T, typename... Args>
        auto invoke(Args&&... args) -> void
        {
            auto callback = get<T>();
            if (callback)
            {
                callback(std::forward<Args>(args)...);
            }
        }
 
        template<std::size_t Index, typename... Args>
        auto invoke_if(bool condition, Args&&... args) -> void
        {
            if (condition)
            {
                invoke<Index>(std::forward<Args>(args)...);
            }
        }
 
        auto clear() -> void
        {
            std::lock_guard lock(mutex_);
            callbacks_ = std::tuple<CallbackTypes...>{};
        }
 
        template<std::size_t Index>
        auto clear() -> void
        {
            std::lock_guard lock(mutex_);
            std::get<Index>(callbacks_) = {};
        }
 
    private:
        mutable std::mutex mutex_;
        std::tuple<CallbackTypes...> callbacks_;
    };
 
    // Convenience type aliases for common callback configurations
 
    using tcp_client_callbacks = callback_manager<
        std::function<void(const std::vector<uint8_t>&)>, // receive
        std::function<void()>,                            // connected
        std::function<void()>,                            // disconnected
        std::function<void(std::error_code)>              // error
        >;
 
    struct tcp_client_callback_index
    {
        static constexpr std::size_t receive = 0;
        static constexpr std::size_t connected = 1;
        static constexpr std::size_t disconnected = 2;
        static constexpr std::size_t error = 3;
    };
 
} // namespace kcenon::network::utils