observer_pattern.cpp File Reference

Demonstrates the connection_observer and callback_adapter patterns. More...

#include <kcenon/network/facade/tcp_facade.h>
#include <kcenon/network/interfaces/connection_observer.h>
#include <kcenon/network/interfaces/i_session.h>
#include <chrono>
#include <iostream>
#include <map>
#include <mutex>
#include <span>
#include <string>
#include <thread>
#include <vector>

Include dependency graph for observer_pattern.cpp:

Go to the source code of this file.

Classes
class	chat_observer
	Custom observer that handles all connection events. More...
class	receive_only_observer
	Partial observer that only handles receive events. More...

Functions
int	main ()

Detailed Description

Demonstrates the connection_observer and callback_adapter patterns.

Definition in file observer_pattern.cpp.

Function Documentation

main()

int main

(

)

Definition at line 97 of file observer_pattern.cpp.

           {
    std::cout << "=== Observer Pattern Example ===" << std::endl;
 
    // --- Start a local echo server ---
    facade::tcp_facade tcp;
    constexpr uint16_t port = 9004;
 
    auto server = tcp.create_server({
        .port = port,
        .server_id = "ObserverTestServer",
    });
 
    std::mutex sessions_mutex;
    std::map<std::string, std::shared_ptr<interfaces::i_session>> sessions;
 
    server->set_connection_callback(
        [&sessions, &sessions_mutex](std::shared_ptr<interfaces::i_session> session) {
            std::lock_guard<std::mutex> lock(sessions_mutex);
            sessions[std::string(session->id())] = session;
        });
 
    server->set_disconnection_callback(
        [&sessions, &sessions_mutex](std::string_view session_id) {
            std::lock_guard<std::mutex> lock(sessions_mutex);
            sessions.erase(std::string(session_id));
        });
 
    server->set_receive_callback(
        [&sessions, &sessions_mutex](std::string_view session_id,
                                     const std::vector<uint8_t>& data) {
            std::lock_guard<std::mutex> lock(sessions_mutex);
            auto it = sessions.find(std::string(session_id));
            if (it != sessions.end()) {
                it->second->send(std::vector<uint8_t>(data));
            }
        });
 
    auto server_result = server->start(port);
    if (server_result.is_err()) {
        std::cerr << "Server start failed: " << server_result.error().message << std::endl;
        return 1;
    }
    std::cout << "Echo server running on port " << port << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
 
    // --- Example 1: Full connection_observer ---
    std::cout << "\n--- Example 1: Full connection_observer ---" << std::endl;
    {
        auto client = tcp.create_client({
            .host = "127.0.0.1",
            .port = port,
            .client_id = "ObserverClient",
        });
 
        auto observer = std::make_shared<chat_observer>("FullObserver");
        client->set_observer(observer);
 
        auto result = client->start("127.0.0.1", port);
        if (result.is_ok()) {
            std::this_thread::sleep_for(std::chrono::milliseconds(200));
 
            std::string msg = "Hello via observer!";
            std::vector<uint8_t> data(msg.begin(), msg.end());
            client->send(std::move(data));
 
            std::this_thread::sleep_for(std::chrono::milliseconds(500));
            std::cout << "Messages received: " << observer->message_count() << std::endl;
        }
 
        client->stop();
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
 
    // --- Example 2: callback_adapter (functional style) ---
    std::cout << "\n--- Example 2: callback_adapter ---" << std::endl;
    {
        auto client = tcp.create_client({
            .host = "127.0.0.1",
            .port = port,
            .client_id = "AdapterClient",
        });
 
        auto adapter = std::make_shared<interfaces::callback_adapter>();
        adapter->on_connected([]() {
                   std::cout << "[Adapter] Connected!" << std::endl;
               })
            .on_receive([](std::span<const uint8_t> data) {
                std::string msg(data.begin(), data.end());
                std::cout << "[Adapter] Received: " << msg << std::endl;
            })
            .on_disconnected([](std::optional<std::string_view> reason) {
                std::cout << "[Adapter] Disconnected." << std::endl;
            })
            .on_error([](std::error_code ec) {
                std::cerr << "[Adapter] Error: " << ec.message() << std::endl;
            });
 
        client->set_observer(adapter);
 
        auto result = client->start("127.0.0.1", port);
        if (result.is_ok()) {
            std::this_thread::sleep_for(std::chrono::milliseconds(200));
 
            std::string msg = "Hello via callback_adapter!";
            std::vector<uint8_t> data(msg.begin(), msg.end());
            client->send(std::move(data));
 
            std::this_thread::sleep_for(std::chrono::milliseconds(500));
        }
 
        client->stop();
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
 
    // --- Cleanup ---
    server->stop();
    std::cout << "\n=== Observer pattern example completed ===" << std::endl;
 
    return 0;
}