connection_observer.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 <memory>
#include <optional>
#include <span>
#include <string_view>
#include <system_error>
 
namespace kcenon::network::interfaces
{
 
    class connection_observer
    {
    public:
        virtual ~connection_observer() = default;
 
        virtual auto on_receive(std::span<const uint8_t> data) -> void = 0;
 
        virtual auto on_connected() -> void = 0;
 
        virtual auto on_disconnected(std::optional<std::string_view> reason = std::nullopt) -> void
            = 0;
 
        virtual auto on_error(std::error_code ec) -> void = 0;
    };
 
    class null_connection_observer : public connection_observer
    {
    public:
        auto on_receive(std::span<const uint8_t> /*data*/) -> void override {}
        auto on_connected() -> void override {}
        auto on_disconnected(std::optional<std::string_view> /*reason*/) -> void override {}
        auto on_error(std::error_code /*ec*/) -> void override {}
    };
 
    class callback_adapter : public connection_observer
    {
    public:
        using receive_fn = std::function<void(std::span<const uint8_t>)>;
        using connected_fn = std::function<void()>;
        using disconnected_fn = std::function<void(std::optional<std::string_view>)>;
        using error_fn = std::function<void(std::error_code)>;
 
        auto on_receive(receive_fn fn) -> callback_adapter&
        {
            receive_callback_ = std::move(fn);
            return *this;
        }
 
        auto on_connected(connected_fn fn) -> callback_adapter&
        {
            connected_callback_ = std::move(fn);
            return *this;
        }
 
        auto on_disconnected(disconnected_fn fn) -> callback_adapter&
        {
            disconnected_callback_ = std::move(fn);
            return *this;
        }
 
        auto on_error(error_fn fn) -> callback_adapter&
        {
            error_callback_ = std::move(fn);
            return *this;
        }
 
        // connection_observer implementation
        auto on_receive(std::span<const uint8_t> data) -> void override
        {
            if (receive_callback_)
            {
                receive_callback_(data);
            }
        }
 
        auto on_connected() -> void override
        {
            if (connected_callback_)
            {
                connected_callback_();
            }
        }
 
        auto on_disconnected(std::optional<std::string_view> reason) -> void override
        {
            if (disconnected_callback_)
            {
                disconnected_callback_(reason);
            }
        }
 
        auto on_error(std::error_code ec) -> void override
        {
            if (error_callback_)
            {
                error_callback_(ec);
            }
        }
 
    private:
        receive_fn receive_callback_;
        connected_fn connected_callback_;
        disconnected_fn disconnected_callback_;
        error_fn error_callback_;
    };
 
} // namespace kcenon::network::interfaces