ModernServer Class Reference

Modern server using new API. More...

Collaboration diagram for ModernServer:

Public Member Functions
	ModernServer (const std::string &id)
bool	start (uint16_t port)
bool	stop ()
void	enable_async_processing ()
void	show_statistics ()

Private Member Functions
void	process_message (const std::string &client_id, const std::string &message)

Private Attributes
std::string	server_id_
uint16_t	port_ = 0
bool	async_enabled_ = false
std::shared_ptr< core::messaging_server >	server_
std::shared_ptr< integration::messaging_bridge >	bridge_
std::vector< std::future< void > >	futures_

Detailed Description

Modern server using new API.

Definition at line 40 of file modern_usage.cpp.

Constructor & Destructor Documentation

ModernServer()

ModernServer::ModernServer ( const std::string & id )

inline

Definition at line 42 of file modern_usage.cpp.

                                      : server_id_(id) {
        server_ = std::make_shared<core::messaging_server>(server_id_);
        bridge_ = std::make_shared<integration::messaging_bridge>();
 
        // Set up thread pool interface
        bridge_->set_thread_pool_interface(
            integration::thread_integration_manager::instance().get_thread_pool()
        );
 
        std::cout << "[Modern Server] Created with ID: " << server_id_ << std::endl;
    }

References bridge_, kcenon::network::integration::thread_integration_manager::instance(), server_, and server_id_.

Here is the call graph for this function:

Member Function Documentation

enable_async_processing()

void ModernServer::enable_async_processing ( )

inline

Definition at line 79 of file modern_usage.cpp.

                                   {
        async_enabled_ = true;
        std::cout << "[Modern Server] Async processing enabled" << std::endl;
    }

References async_enabled_.

process_message()

void ModernServer::process_message ( const std::string & client_id, const std::string & message )

inlineprivate

Definition at line 103 of file modern_usage.cpp.

                                                                               {
        std::cout << "[Modern Server] Processing from " << client_id
                  << ": " << message << std::endl;
 
        if (async_enabled_) {
            // Process asynchronously using thread pool
            auto& thread_mgr = integration::thread_integration_manager::instance();
            auto future = thread_mgr.submit_task([message]() {
                // Simulate complex processing
                std::this_thread::sleep_for(50ms);
                std::cout << "[Async Processor] Completed processing: " << message << std::endl;
            });
 
            // Don't wait - let it process in background
            futures_.push_back(std::move(future));
        }
 
        // Use container system for demonstration
        auto& container_mgr = integration::container_manager::instance();
        std::string response = "Processed: " + message;
 
        // Serialize and deserialize to demonstrate container usage
        auto serialized = container_mgr.serialize(std::any(response));
        auto deserialized = container_mgr.deserialize(serialized);
 
        if (deserialized.has_value()) {
            std::cout << "[Modern Server] Container processed: "
                      << std::any_cast<std::string>(deserialized) << std::endl;
        }
    }

References async_enabled_, futures_, kcenon::network::integration::container_manager::instance(), kcenon::network::integration::thread_integration_manager::instance(), and kcenon::network::message.

Here is the call graph for this function:

show_statistics()

void ModernServer::show_statistics ( )

inline

Definition at line 84 of file modern_usage.cpp.

                           {
        auto metrics = bridge_->get_metrics();
        auto thread_metrics = integration::thread_integration_manager::instance().get_metrics();
 
        std::cout << "\n=== Server Statistics ===" << std::endl;
        std::cout << "Network Metrics:" << std::endl;
        std::cout << "  Messages sent: " << metrics.messages_sent << std::endl;
        std::cout << "  Messages received: " << metrics.messages_received << std::endl;
        std::cout << "  Bytes sent: " << metrics.bytes_sent << std::endl;
        std::cout << "  Bytes received: " << metrics.bytes_received << std::endl;
        std::cout << "  Active connections: " << metrics.connections_active << std::endl;
 
        std::cout << "\nThread Pool Metrics:" << std::endl;
        std::cout << "  Worker threads: " << thread_metrics.worker_threads << std::endl;
        std::cout << "  Pending tasks: " << thread_metrics.pending_tasks << std::endl;
        std::cout << "  Completed tasks: " << thread_metrics.completed_tasks << std::endl;
    }

References bridge_, kcenon::network::integration::thread_integration_manager::get_metrics(), kcenon::network::integration::thread_integration_manager::instance(), and kcenon::network::integration::thread_integration_manager::metrics::worker_threads.

Here is the call graph for this function:

start()

bool ModernServer::start ( uint16_t port )

inline

Definition at line 54 of file modern_usage.cpp.

                              {
        auto result = server_->start_server(port);
        if (result.is_err()) {
            std::cerr << "[Modern Server] Failed to start: " << result.error().message
                      << " (code: " << result.error().code << ")" << std::endl;
            return false;
        }
 
        port_ = port;
        std::cout << "[Modern Server] Started on port " << port << std::endl;
        return true;
    }

References port_, server_, and kcenon::network::core::messaging_server::start_server().

Here is the call graph for this function:

stop()

bool ModernServer::stop ( )

inline

Definition at line 67 of file modern_usage.cpp.

                {
        auto result = server_->stop_server();
        if (result.is_err()) {
            std::cerr << "[Modern Server] Failed to stop: " << result.error().message
                      << " (code: " << result.error().code << ")" << std::endl;
            return false;
        }
 
        std::cout << "[Modern Server] Stopped" << std::endl;
        return true;
    }

References server_, and kcenon::network::core::messaging_server::stop_server().

Here is the call graph for this function:

Member Data Documentation

async_enabled_

bool ModernServer::async_enabled_ = false

private

Definition at line 136 of file modern_usage.cpp.

Referenced by enable_async_processing(), and process_message().

bridge_

std::shared_ptr<integration::messaging_bridge> ModernServer::bridge_

private

Definition at line 138 of file modern_usage.cpp.

Referenced by ModernServer(), and show_statistics().

futures_

std::vector<std::future<void> > ModernServer::futures_

private

Definition at line 139 of file modern_usage.cpp.

Referenced by process_message().

port_

uint16_t ModernServer::port_ = 0

private

Definition at line 135 of file modern_usage.cpp.

Referenced by start().

server_

std::shared_ptr<core::messaging_server> ModernServer::server_

private

Definition at line 137 of file modern_usage.cpp.

Referenced by ModernServer(), start(), and stop().

server_id_

std::string ModernServer::server_id_

private

Definition at line 134 of file modern_usage.cpp.

Referenced by ModernServer().

---

The documentation for this class was generated from the following file:

• examples/messaging_system_integration/modern_usage.cpp