messaging_client.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
#ifndef KCENON_NETWORK_INTERNAL_CORE_MESSAGING_CLIENT_H_
#define KCENON_NETWORK_INTERNAL_CORE_MESSAGING_CLIENT_H_
 
#include <atomic>
#include <functional>
#include <future>
#include <memory>
#include <mutex>
#include <span>
#include <string>
#include <string_view>
#include <type_traits>
 
#include <asio.hpp>
 
#include "internal/core/callback_indices.h"
#include "internal/tcp/tcp_socket.h"
#include "internal/integration/io_context_thread_manager.h"
#include "kcenon/network/detail/utils/startable_base.h"
#include "kcenon/network/detail/utils/callback_manager.h"
#include "kcenon/network/detail/utils/result_types.h"
#include "kcenon/network/interfaces/i_protocol_client.h"
#include "kcenon/network/interfaces/connection_observer.h"
 
// Use nested namespace definition in C++17
namespace kcenon::network::core
{
 
    class messaging_client
        : public std::enable_shared_from_this<messaging_client>
        , public utils::startable_base<messaging_client>
        , public interfaces::i_protocol_client
    {
        friend class utils::startable_base<messaging_client>;
 
    public:
        // =====================================================================
        // INetworkComponent Interface Implementation (via IProtocolClient)
        // =====================================================================
 
        [[nodiscard]] auto is_running() const -> bool override
        {
            return utils::startable_base<messaging_client>::is_running();
        }
 
        auto wait_for_stop() -> void override
        {
            return utils::startable_base<messaging_client>::wait_for_stop();
        }
        using receive_callback_t = std::function<void(const std::vector<uint8_t>&)>;
        using connected_callback_t = std::function<void()>;
        using disconnected_callback_t = std::function<void()>;
        using error_callback_t = std::function<void(std::error_code)>;
 
        explicit messaging_client(std::string_view client_id);
 
        ~messaging_client() noexcept;
 
        // Non-copyable, non-movable
        messaging_client(const messaging_client&) = delete;
        messaging_client& operator=(const messaging_client&) = delete;
        messaging_client(messaging_client&&) = delete;
        messaging_client& operator=(messaging_client&&) = delete;
 
        // =====================================================================
        // IProtocolClient Interface Implementation
        // =====================================================================
 
        [[nodiscard]] auto start(std::string_view host, uint16_t port) -> VoidResult override;
 
        [[nodiscard]] auto stop() -> VoidResult override;
 
        [[nodiscard]] auto send(std::vector<uint8_t>&& data) -> VoidResult override;
 
        [[nodiscard]] auto is_connected() const -> bool override;
 
        auto set_observer(std::shared_ptr<interfaces::connection_observer> observer) -> void override;
 
        // =====================================================================
        // Lifecycle Management (Legacy API)
        // =====================================================================
 
        [[nodiscard]] auto start_client(std::string_view host, unsigned short port) -> VoidResult;
 
        [[nodiscard]] auto stop_client() -> VoidResult;
 
        // Note: wait_for_stop() and is_running() are inherited from startable_base
        // Note: is_connected() is declared in IProtocolClient interface section
 
        [[nodiscard]] auto client_id() const -> const std::string&;
 
        // =====================================================================
        // Data Transfer
        // =====================================================================
 
        [[nodiscard]] auto send_packet(std::vector<uint8_t>&& data) -> VoidResult;
 
        // =====================================================================
        // Callback Setters (IProtocolClient interface)
        // =====================================================================
 
        auto set_receive_callback(receive_callback_t callback) -> void override;
        auto set_connected_callback(connected_callback_t callback) -> void override;
        auto set_disconnected_callback(disconnected_callback_t callback) -> void override;
        auto set_error_callback(error_callback_t callback) -> void override;
 
    private:
        // =====================================================================
        // startable_base CRTP interface
        // =====================================================================
 
        [[nodiscard]] static constexpr auto component_name() noexcept -> std::string_view
        {
            return "Client";
        }
 
        auto on_stopped() -> void;
 
        // =====================================================================
        // Internal Implementation Methods
        // =====================================================================
 
        auto do_start_impl(std::string_view host, unsigned short port) -> VoidResult;
 
        auto do_stop_impl() -> VoidResult;
 
        auto do_send_impl(std::vector<uint8_t>&& data) -> VoidResult;
 
        // =====================================================================
        // Internal Callback Helpers
        // =====================================================================
 
        auto set_connected(bool connected) -> void;
 
        auto invoke_receive_callback(const std::vector<uint8_t>& data) -> void;
 
        auto invoke_connected_callback() -> void;
 
        auto invoke_disconnected_callback() -> void;
 
        auto invoke_error_callback(std::error_code ec) -> void;
 
        // =====================================================================
        // Internal Connection Handlers
        // =====================================================================
 
        auto do_connect(std::string_view host, unsigned short port) -> void;
 
        auto on_connect(std::error_code ec) -> void;
 
        auto on_receive(std::span<const uint8_t> data) -> void;
 
        auto on_error(std::error_code ec) -> void;
 
        auto on_connection_failed(std::error_code ec) -> void;
 
    private:
        using callback_index = tcp_client_callback;
 
        using callbacks_t = utils::callback_manager<
            receive_callback_t,
            connected_callback_t,
            disconnected_callback_t,
            error_callback_t
        >;
 
        // =====================================================================
        // Member Variables
        // =====================================================================
 
        std::string client_id_;              
        // Note: lifecycle_ and stop_initiated_ are managed by startable_base
        callbacks_t callbacks_;              
        std::atomic<bool> is_connected_{false}; 
        std::shared_ptr<interfaces::connection_observer> observer_;
 
        std::shared_ptr<asio::io_context>
            io_context_; 
        std::unique_ptr<asio::executor_work_guard<asio::io_context::executor_type>>
            work_guard_; 
        std::future<void>
            io_context_future_; 
        auto get_socket() const -> std::shared_ptr<internal::tcp_socket>;
 
        mutable std::mutex socket_mutex_; 
        std::shared_ptr<internal::tcp_socket>
            socket_;   
        mutable std::mutex pending_mutex_; 
        std::shared_ptr<asio::ip::tcp::resolver> pending_resolver_;
        std::shared_ptr<asio::ip::tcp::socket> pending_socket_;
    };
 
} // namespace kcenon::network::core
 
#endif // KCENON_NETWORK_INTERNAL_CORE_MESSAGING_CLIENT_H_