modern_usage.cpp File Reference

Example of using network_system with modern API and Result<T> pattern. More...

#include <iostream>
#include <memory>
#include <thread>
#include <chrono>
#include <vector>
#include <future>
#include "kcenon/network/network_system.h"

Include dependency graph for modern_usage.cpp:

Go to the source code of this file.

Classes
class	ModernServer
	Modern server using new API. More...
class	ModernClient
	Modern client using new API. More...

Functions
void	demonstrate_advanced_features ()
	Demonstrate advanced features.
int	main (int argc, char *argv[])
	Main function demonstrating modern usage.

Detailed Description

Example of using network_system with modern API and Result<T> pattern.

This example demonstrates:

• Modern network_system API with Result<T> error handling
• Type-safe error checking with VoidResult return types
• Integration with thread pool and container systems
• Proper error handling and recovery patterns

Note: All primary APIs (start_server, start_client, send_packet, etc.) now return Result<T> for type-safe error handling instead of throwing exceptions or using callback-only error reporting.

Author

kcenon

Date

2025-09-20 @updated 2025-10-10 - Added Result<T> pattern support

Definition in file modern_usage.cpp.

Function Documentation

demonstrate_advanced_features()

void demonstrate_advanced_features

(

)

Demonstrate advanced features.

Definition at line 224 of file modern_usage.cpp.

                                     {
    std::cout << "\n=== Advanced Features Demo ===" << std::endl;
 
    // Custom container with serialization
    auto custom_container = std::make_shared<integration::basic_container>();
 
    // Set custom serializer for complex types
    custom_container->set_serializer([](const std::any& data) {
        std::vector<uint8_t> result;
        if (data.type() == typeid(std::vector<int>)) {
            auto vec = std::any_cast<std::vector<int>>(data);
            result.reserve(vec.size() * sizeof(int));
            for (int val : vec) {
                auto bytes = reinterpret_cast<const uint8_t*>(&val);
                result.insert(result.end(), bytes, bytes + sizeof(int));
            }
        }
        return result;
    });
 
    // Register custom container
    integration::container_manager::instance().register_container(
        "custom_vector_serializer", custom_container
    );
 
    // Test custom serialization
    std::vector<int> test_data = {1, 2, 3, 4, 5};
    auto serialized = custom_container->serialize(std::any(test_data));
    std::cout << "Custom serialized " << test_data.size()
              << " integers to " << serialized.size() << " bytes" << std::endl;
 
    // Thread pool advanced usage
    auto& thread_mgr = integration::thread_integration_manager::instance();
    std::vector<std::future<void>> tasks;
 
    // Submit multiple delayed tasks
    for (int i = 1; i <= 3; ++i) {
        auto future = thread_mgr.submit_delayed_task(
            [i]() {
                std::cout << "[Delayed Task " << i << "] Executed after delay" << std::endl;
            },
            std::chrono::milliseconds(i * 100)
        );
        tasks.push_back(std::move(future));
    }
 
    // Wait for all tasks
    for (auto& future : tasks) {
        future.wait();
    }
 
    std::cout << "All advanced features demonstrated successfully" << std::endl;
}

References kcenon::network::integration::container_manager::instance(), kcenon::network::integration::thread_integration_manager::instance(), and kcenon::network::integration::container_manager::register_container().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *	argv[] )

Main function demonstrating modern usage.

Definition at line 281 of file modern_usage.cpp.

                                 {
    std::cout << "=== Modern Network System Usage Demo ===" << std::endl;
    std::cout << "Demonstrating the new API with all integration features" << std::endl;
 
    // Initialize using modern API
    kcenon::network::compat::initialize();
    std::cout << "\n✓ Network system initialized" << std::endl;
 
    try {
        // Create modern server
        ModernServer server("modern_server_001");
        server.enable_async_processing();
 
        if (!server.start(9090)) {
            std::cerr << "Failed to start server, aborting demo" << std::endl;
            return 1;
        }
 
        // Allow server to start
        std::this_thread::sleep_for(500ms);
 
        // Create modern client
        ModernClient client("modern_client_001");
 
        if (!client.connect("127.0.0.1", 9090)) {
            std::cerr << "Failed to connect client, stopping server" << std::endl;
            server.stop();
            return 1;
        }
 
        // Send batch messages
        std::vector<std::string> batch = {
            "Modern message 1",
            "Modern message 2",
            "Modern message 3"
        };
        size_t sent = client.send_batch(batch);
 
        if (sent < batch.size()) {
            std::cout << "[Warning] Not all messages were sent successfully" << std::endl;
        }
 
        // Send async messages
        for (int i = 1; i <= 3; ++i) {
            client.send_async("Async message " + std::to_string(i));
        }
 
        // Wait for async operations
        std::this_thread::sleep_for(500ms);
 
        // Show server statistics
        server.show_statistics();
 
        // Disconnect
        if (!client.disconnect()) {
            std::cout << "[Warning] Client disconnection had issues" << std::endl;
        }
 
        // Demonstrate advanced features
        demonstrate_advanced_features();
 
        // Stop server
        if (!server.stop()) {
            std::cout << "[Warning] Server shutdown had issues" << std::endl;
        }
 
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }
 
    // Shutdown
    kcenon::network::compat::shutdown();
    std::cout << "\n✓ Network system shutdown complete" << std::endl;
 
    std::cout << "\n=== Modern Usage Demo Complete ===" << std::endl;
    std::cout << "All modern features working perfectly!" << std::endl;
 
    return 0;
}

References demonstrate_advanced_features().

Here is the call graph for this function: