composition_example.cpp File Reference

Composition-based design with service container, logger, and monitoring. More...

#include <iostream>
#include <chrono>
#include <thread>
#include <kcenon/thread/interfaces/service_container.h>
#include <kcenon/thread/interfaces/thread_context.h>
#include <kcenon/common/interfaces/logger_interface.h>
#include <kcenon/common/interfaces/global_logger_registry.h>
#include <kcenon/common/interfaces/monitoring_interface.h>
#include <kcenon/thread/core/thread_pool.h>
#include <kcenon/thread/core/callback_job.h>
#include <kcenon/thread/core/log_level.h>

Include dependency graph for composition_example.cpp:

Go to the source code of this file.

Classes
class	console_logger
	Simple console logger implementation using common_system ILogger. More...
class	console_monitoring
	Simple monitoring implementation using common::interfaces::IMonitor. More...

Typedefs
using	common_log_level = kcenon::common::interfaces::log_level

Functions
void	demonstrate_composition ()
	Demonstrate composition-based design.
void	demonstrate_minimal_usage ()
	Demonstrate using thread pool without any services.
int	main ()

Detailed Description

Composition-based design with service container, logger, and monitoring.

Definition in file composition_example.cpp.

Typedef Documentation

common_log_level

using common_log_level = kcenon::common::interfaces::log_level

Definition at line 33 of file composition_example.cpp.

Function Documentation

demonstrate_composition()

void demonstrate_composition

(

)

Demonstrate composition-based design.

Examples

composition_example.cpp.

Definition at line 154 of file composition_example.cpp.

                               {
    std::cout << "\n=== Composition-Based Thread System Demo ===\n" << std::endl;
    
    // 1. Setup service container with implementations
    auto& container = service_container::global();
    
    // Register logger service
    container.register_singleton<kcenon::common::interfaces::ILogger>(
        std::make_shared<console_logger>());
    
    // Register monitoring service
    container.register_singleton<kcenon::common::interfaces::IMonitor>(
        std::make_shared<console_monitoring>());
    
    // 2. Create thread pool with context from global container
    thread_context context; // Will resolve services from container
    auto pool = std::make_shared<thread_pool>("CompositionPool", context);
    
    // 3. Add workers - they inherit context from pool
    std::vector<std::unique_ptr<thread_worker>> workers;
    for (int i = 0; i < 4; ++i) {
        workers.push_back(std::make_unique<thread_worker>());
    }
    {
        auto r = pool->enqueue_batch(std::move(workers));
        if (r.is_err()) {
            std::cerr << "enqueue_batch failed: " << r.error().message << std::endl;
            return;
        }
    }
 
    // 4. Start pool - will log through context
    {
        auto r = pool->start();
        if (r.is_err()) {
            std::cerr << "start failed: " << r.error().message << std::endl;
            return;
        }
    }
 
    // 5. Submit jobs that will be logged
    for (int i = 0; i < 10; ++i) {
        auto r = pool->enqueue(std::make_unique<callback_job>(
            [i, &context]() -> kcenon::common::VoidResult {
                context.log(log_level_v2::info,
                    "Processing job " + std::to_string(i));
 
                // Simulate work
                std::this_thread::sleep_for(std::chrono::milliseconds(100));
 
                return kcenon::common::ok();
            }
        ));
        if (r.is_err()) {
            std::cerr << "enqueue failed: " << r.error().message << std::endl;
        }
    }
 
    // 6. Wait for completion
    std::this_thread::sleep_for(std::chrono::seconds(2));
 
    // 7. Stop pool
    {
        auto r = pool->stop();
        if (r.is_err()) {
            std::cerr << "stop failed: " << r.error().message << std::endl;
        }
    }
    
    std::cout << "\n=== Basic Thread Pool Demo Complete ===\n" << std::endl;
}

References kcenon::thread::service_container::global().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

demonstrate_minimal_usage()

void demonstrate_minimal_usage

(

)

Demonstrate using thread pool without any services.

Examples

composition_example.cpp.

Definition at line 306 of file composition_example.cpp.

                                 {
    std::cout << "\n=== Minimal Thread Pool (No Services) Demo ===\n" << std::endl;
    
    // Clear any existing services
    service_container::global().clear();
    
    // Create pool without context - no logging or monitoring
    auto pool = std::make_shared<thread_pool>("MinimalPool");
    
    // Add workers
    std::vector<std::unique_ptr<thread_worker>> workers;
    for (int i = 0; i < 2; ++i) {
        workers.push_back(std::make_unique<thread_worker>());
    }
    {
        auto r = pool->enqueue_batch(std::move(workers));
        if (r.is_err()) {
            std::cerr << "enqueue_batch failed: " << r.error().message << std::endl;
            return;
        }
    }
 
    {
        auto r = pool->start();
        if (r.is_err()) {
            std::cerr << "start failed: " << r.error().message << std::endl;
            return;
        }
    }
 
    // Submit jobs - no logging will occur
    std::atomic<int> counter{0};
    for (int i = 0; i < 5; ++i) {
        auto r = pool->enqueue(std::make_unique<callback_job>(
            [&counter]() -> kcenon::common::VoidResult {
                counter.fetch_add(1);
                return kcenon::common::ok();
            }
        ));
        if (r.is_err()) {
            std::cerr << "enqueue failed: " << r.error().message << std::endl;
        }
    }
 
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    {
        auto r = pool->stop();
        if (r.is_err()) {
            std::cerr << "stop failed: " << r.error().message << std::endl;
        }
    }
    
    std::cout << "Completed " << counter.load() << " jobs without any logging/monitoring" << std::endl;
    std::cout << "\n=== Minimal Demo Complete ===\n" << std::endl;
}

References kcenon::thread::service_container::clear(), and kcenon::thread::service_container::global().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main

(

)

Definition at line 362 of file composition_example.cpp.

           {
    try {
        // Show different usage patterns
        demonstrate_minimal_usage();
        demonstrate_composition();
        // demonstrate_typed_pool_composition(); // Temporarily disabled - requires typed_pool implementation
        
        // Clean up
        service_container::global().clear();
        
        std::cout << "\nAll demos completed successfully!" << std::endl;
        
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }
    
    return 0;
}

References kcenon::thread::service_container::clear(), demonstrate_composition(), demonstrate_minimal_usage(), and kcenon::thread::service_container::global().

Here is the call graph for this function: