di_pattern_example.cpp File Reference

Dependency Injection pattern example for logger_system Phase 4. More...

#include <kcenon/logger/core/logger_builder.h>
#include <kcenon/common/interfaces/logger_interface.h>
#include <kcenon/common/interfaces/monitoring_interface.h>
#include <iostream>
#include <memory>
#include <thread>
#include <chrono>
#include <mutex>
#include <unordered_map>
#include <sstream>

Include dependency graph for di_pattern_example.cpp:

Go to the source code of this file.

Classes
class	example_monitor
	Example monitor implementation demonstrating IMonitor interface. More...

Functions
void	example_1_basic_di_pattern ()
	Example demonstrating DI pattern with logger and monitor.
void	example_2_optional_monitor ()
	Example demonstrating monitor-less operation.
void	example_3_runtime_monitor_injection ()
	Example demonstrating runtime monitor injection.
void	example_4_monitor_swapping ()
	Example demonstrating monitor swapping.
void	use_logger_via_interface (std::shared_ptr< ci::ILogger > logger)
	Example demonstrating ILogger interface usage.
void	example_5_interface_based_usage ()
int	main ()

Detailed Description

Dependency Injection pattern example for logger_system Phase 4.

Definition in file di_pattern_example.cpp.

Function Documentation

example_1_basic_di_pattern()

void example_1_basic_di_pattern

(

)

Example demonstrating DI pattern with logger and monitor.

Examples

di_pattern_example.cpp.

Definition at line 185 of file di_pattern_example.cpp.

                                  {
    std::cout << "\n=== Example 1: Basic Dependency Injection ===" << std::endl;
 
    // Step 1: Create monitor instance (can be any IMonitor implementation)
    auto monitor = std::make_shared<example_monitor>();
 
    // Step 2: Inject monitor into logger via builder pattern
    auto logger_result = logger_builder()
        .with_async(false)
        .with_monitoring(monitor)  // DI: Inject monitor interface
        .with_min_level(ci::log_level::debug)
        .build();
 
    if (!logger_result) {
        std::cerr << "Failed to create logger: "
                  << logger_result.error_message() << std::endl;
        return;
    }
 
    auto logger_instance = std::shared_ptr<logger>(std::move(logger_result.value()));
 
    // Step 3: Use logger - metrics are automatically recorded to monitor
    logger_instance->log(ci::log_level::info, "Application started");
    logger_instance->log(ci::log_level::debug, "Debug message");
    logger_instance->log(ci::log_level::warning, "Warning message");
 
    // Step 4: Verify metrics were recorded
    std::cout << "\nMonitor collected " << monitor->get_metric_count()
              << " metrics" << std::endl;
 
    // Step 5: Get health status from logger (IMonitorable interface)
    // TODO: Implement health_check() in logger class (Phase 2.2)
    // auto health = logger_instance->health_check();
    // if (kcenon::common::is_ok(health)) {
    //     std::cout << "Logger health: "
    //               << ci::to_string(kcenon::common::get_value(health).status) << std::endl;
    // }
    std::cout << "Logger health: [health_check() not yet implemented]" << std::endl;
}

References kcenon::logger::logger_builder::build(), kcenon::logger::logger_builder::with_async(), kcenon::logger::logger_builder::with_min_level(), and kcenon::logger::logger_builder::with_monitoring().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

example_2_optional_monitor()

void example_2_optional_monitor

(

)

Example demonstrating monitor-less operation.

Examples

di_pattern_example.cpp.

Definition at line 228 of file di_pattern_example.cpp.

                                  {
    std::cout << "\n=== Example 2: Optional Monitor (No Monitor) ===" << std::endl;
 
    // Build logger without monitor - demonstrates optional dependency
    auto logger_result = logger_builder()
        .with_async(false)
        .with_min_level(ci::log_level::info)
        .build();
 
    if (!logger_result) {
        std::cerr << "Failed to create logger" << std::endl;
        return;
    }
 
    auto logger_instance = std::shared_ptr<logger>(std::move(logger_result.value()));
 
    // Logger works fine without monitor
    logger_instance->log(ci::log_level::info, "Operating without monitor");
    logger_instance->log(ci::log_level::warning, "Warning without monitoring");
 
    std::cout << "Logger operates successfully without monitor (DI optional)" << std::endl;
}

References kcenon::logger::logger_builder::build(), kcenon::logger::logger_builder::with_async(), and kcenon::logger::logger_builder::with_min_level().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

example_3_runtime_monitor_injection()

void example_3_runtime_monitor_injection

(

)

Example demonstrating runtime monitor injection.

Examples

di_pattern_example.cpp.

Definition at line 254 of file di_pattern_example.cpp.

                                           {
    std::cout << "\n=== Example 3: Runtime Monitor Injection ===" << std::endl;
 
    // Create logger without monitor initially
    auto logger_result = logger_builder()
        .with_async(false)
        .build();
 
    if (!logger_result) {
        std::cerr << "Failed to create logger" << std::endl;
        return;
    }
 
    auto logger_instance = std::shared_ptr<logger>(std::move(logger_result.value()));
 
    std::cout << "Phase 1: Operating without monitor" << std::endl;
    logger_instance->log(ci::log_level::info, "Message 1 - no monitoring");
 
    // Inject monitor at runtime
    // TODO: Implement set_monitor() in logger class (Phase 2.2)
    auto monitor = std::make_unique<example_monitor>();
    auto* monitor_ref = monitor.get();
    // logger_instance->set_monitor(std::move(monitor));
 
    std::cout << "\nPhase 2: Monitor injected at runtime [set_monitor() not yet implemented]" << std::endl;
    logger_instance->log(ci::log_level::info, "Message 2 - with monitoring");
    logger_instance->log(ci::log_level::info, "Message 3 - with monitoring");
 
    std::cout << "\nMonitor recorded " << monitor_ref->get_metric_count()
              << " metrics (only from Phase 2)" << std::endl;
}

References kcenon::logger::logger_builder::build(), and kcenon::logger::logger_builder::with_async().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

example_4_monitor_swapping()

void example_4_monitor_swapping

(

)

Example demonstrating monitor swapping.

Examples

di_pattern_example.cpp.

Definition at line 289 of file di_pattern_example.cpp.

                                  {
    std::cout << "\n=== Example 4: Monitor Swapping ===" << std::endl;
 
    auto logger_result = logger_builder()
        .with_async(false)
        .build();
 
    if (!logger_result) return;
    auto logger_instance = std::shared_ptr<logger>(std::move(logger_result.value()));
 
    // TODO: Implement set_monitor() in logger class (Phase 2.2)
    auto monitor1 = std::make_unique<example_monitor>();
    auto* monitor1_ref = monitor1.get();
    // logger_instance->set_monitor(std::move(monitor1));
 
    std::cout << "Using Monitor 1 [set_monitor() not yet implemented]" << std::endl;
    logger_instance->log(ci::log_level::info, "Message to Monitor 1");
    logger_instance->log(ci::log_level::info, "Another message to Monitor 1");
 
    size_t monitor1_metrics = monitor1_ref->get_metric_count();
 
    // Swap monitors at runtime
    auto monitor2 = std::make_unique<example_monitor>();
    auto* monitor2_ref = monitor2.get();
    // logger_instance->set_monitor(std::move(monitor2));
 
    std::cout << "\nSwapped to Monitor 2 [set_monitor() not yet implemented]" << std::endl;
    logger_instance->log(ci::log_level::info, "Message to Monitor 2");
 
    size_t monitor2_metrics = monitor2_ref->get_metric_count();
 
    std::cout << "\nMonitor 1 metrics before swap: " << monitor1_metrics << std::endl;
    std::cout << "Monitor 2 metrics after swap: " << monitor2_metrics << std::endl;
}

References kcenon::logger::logger_builder::build(), and kcenon::logger::logger_builder::with_async().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

example_5_interface_based_usage()

void example_5_interface_based_usage

(

)

Examples

di_pattern_example.cpp.

Definition at line 344 of file di_pattern_example.cpp.

                                       {
    std::cout << "\n=== Example 5: Interface-Based Usage ===" << std::endl;
 
    auto monitor = std::make_shared<example_monitor>();
    auto logger_result = logger_builder()
        .with_async(false)
        .with_monitoring(monitor)
        .build();
 
    if (!logger_result) return;
 
    // Use logger through ILogger interface pointer
    auto logger_instance = std::shared_ptr<logger>(std::move(logger_result.value()));
    auto logger_adapter = std::make_shared<logger_interface_adapter>(logger_instance);
    std::shared_ptr<ci::ILogger> logger_interface = logger_adapter;
 
    use_logger_via_interface(logger_interface);
 
    std::cout << "Successfully used logger through interface abstraction" << std::endl;
}

References kcenon::logger::logger_builder::build(), use_logger_via_interface(), kcenon::logger::logger_builder::with_async(), and kcenon::logger::logger_builder::with_monitoring().

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 365 of file di_pattern_example.cpp.

           {
    std::cout << "==================================================" << std::endl;
    std::cout << "Logger System - Dependency Injection Pattern Demo" << std::endl;
    std::cout << "Phase 4: DI Pattern Implementation Examples" << std::endl;
    std::cout << "==================================================" << std::endl;
 
    try {
        example_1_basic_di_pattern();
        example_2_optional_monitor();
        example_3_runtime_monitor_injection();
        example_4_monitor_swapping();
        example_5_interface_based_usage();
 
        std::cout << "\n==================================================" << std::endl;
        std::cout << "All DI pattern examples completed successfully!" << std::endl;
        std::cout << "==================================================" << std::endl;
 
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }
 
    return 0;
}

References example_1_basic_di_pattern(), example_2_optional_monitor(), example_3_runtime_monitor_injection(), example_4_monitor_swapping(), and example_5_interface_based_usage().

Here is the call graph for this function:

use_logger_via_interface()

void use_logger_via_interface

(

std::shared_ptr< ci::ILogger >

logger

)

Example demonstrating ILogger interface usage.

Examples

di_pattern_example.cpp.

Definition at line 327 of file di_pattern_example.cpp.

                                                               {
    // This function only depends on ILogger interface
    // Can work with any logger implementation
 
    // Use std::string explicitly to avoid ambiguity between log overloads
    logger->log(ci::log_level::info, std::string("Used via interface - loose coupling!"));
 
    // Check if logger supports monitoring (IMonitorable)
    if (auto monitorable = std::dynamic_pointer_cast<ci::IMonitorable>(logger)) {
        auto data = monitorable->get_monitoring_data();
        if (kcenon::common::is_ok(data)) {
            std::cout << "Logger provides monitoring data from "
                      << kcenon::common::get_value(data).source_id << std::endl;
        }
    }
}

References kcenon::common::get_value(), and kcenon::common::is_ok().

Referenced by example_5_interface_based_usage().

Here is the call graph for this function:

Here is the caller graph for this function: