bidirectional_di_example.cpp File Reference

Phase 4 - Bidirectional Dependency Injection Example. More...

#include <kcenon/monitoring/core/performance_monitor.h>
#include <kcenon/common/interfaces/logger_interface.h>
#include <kcenon/common/interfaces/monitoring_interface.h>
#include <iostream>
#include <memory>
#include <chrono>
#include <thread>

Include dependency graph for bidirectional_di_example.cpp:

Go to the source code of this file.

Classes
class	console_logger
	Simple console logger implementing ILogger interface. More...

Functions
void	demo_standalone_systems ()
	Scenario 1: Standalone Systems.
void	demo_logger_with_monitor ()
	Scenario 2: Logger with Monitor Injection.
void	demo_monitor_with_logger ()
	Scenario 3: Monitor with Logger Injection (via adapter)
void	demo_bidirectional_integration ()
	Scenario 4: Bidirectional DI (THE KEY DEMO!)
void	demo_runtime_flexibility ()
	Scenario 5: Runtime Flexibility.
int	main ()

Detailed Description

Phase 4 - Bidirectional Dependency Injection Example.

Definition in file bidirectional_di_example.cpp.

Function Documentation

demo_bidirectional_integration()

void demo_bidirectional_integration

(

)

Scenario 4: Bidirectional DI (THE KEY DEMO!)

Examples

bidirectional_di_example.cpp.

Definition at line 212 of file bidirectional_di_example.cpp.

                                      {
    std::cout << "\n\n=== Scenario 4: Bidirectional DI (No Circular Dependency!) ===" << std::endl;
    std::cout << "Both systems integrated at RUNTIME without compile-time circular dependency.\n" << std::endl;
 
    // Create both systems
    auto logger = std::make_shared<console_logger>();
    auto monitor = std::make_shared<performance_monitor>();
 
    // Bidirectional injection
    logger->set_monitor(monitor);
    // Note: In real logger_system, logger would also be injected into adapter
 
    std::cout << "\n✓ Bidirectional dependency injection complete" << std::endl;
    std::cout << "  Logger -> uses Monitor for metrics" << std::endl;
    std::cout << "  Monitor <- logs status via Logger\n" << std::endl;
 
    // Simulate application workload
    std::cout << "\nSimulating application workload..." << std::endl;
    for (int i = 0; i < 10; ++i) {
        // Log activity
        logger->log(log_level::info, "Processing request " + std::to_string(i));
 
        // Record performance metrics
        monitor->record_metric("requests_processed", i + 1);
        monitor->record_metric("response_time_ms", 50.0 + (i * 5));
 
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
 
    // Check both systems' health
    std::cout << "\n=== System Health Check ===" << std::endl;
 
    auto logger_health = logger->health_check();
    if (std::holds_alternative<health_check_result>(logger_health)) {
        auto& health = std::get<health_check_result>(logger_health);
        std::cout << "Logger Status: " << to_string(health.status)
                  << " - " << health.message << std::endl;
        std::cout << "  Messages logged: " << logger->get_message_count() << std::endl;
    }
 
    auto monitor_health = monitor->check_health();
    if (std::holds_alternative<health_check_result>(monitor_health)) {
        auto& health = std::get<health_check_result>(monitor_health);
        std::cout << "Monitor Status: " << to_string(health.status)
                  << " - " << health.message << std::endl;
    }
 
    // Get comprehensive metrics
    std::cout << "\n=== Collected Metrics ===" << std::endl;
 
    auto logger_metrics = logger->get_monitoring_data();
    if (std::holds_alternative<metrics_snapshot>(logger_metrics)) {
        auto& snapshot = std::get<metrics_snapshot>(logger_metrics);
        std::cout << "Logger Metrics:" << std::endl;
        for (const auto& metric : snapshot.metrics) {
            std::cout << "  " << metric.name << ": " << metric.value << std::endl;
        }
    }
 
    auto monitor_metrics = monitor->get_metrics();
    if (std::holds_alternative<metrics_snapshot>(monitor_metrics)) {
        auto& snapshot = std::get<metrics_snapshot>(monitor_metrics);
        std::cout << "\nMonitor Metrics:" << std::endl;
        for (const auto& metric : snapshot.metrics) {
            std::cout << "  " << metric.name << ": " << metric.value << std::endl;
        }
    }
 
    std::cout << "\n✓ Both systems fully operational and integrated!" << std::endl;
}

References kcenon::monitoring::metric::name, kcenon::monitoring::to_string(), and kcenon::monitoring::metric::value.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

demo_logger_with_monitor()

void demo_logger_with_monitor

(

)

Scenario 2: Logger with Monitor Injection.

Examples

bidirectional_di_example.cpp.

Definition at line 156 of file bidirectional_di_example.cpp.

                                {
    std::cout << "\n=== Scenario 2: Logger with Monitor ===" << std::endl;
    std::cout << "Logger receives monitor via DI for metrics collection.\n" << std::endl;
 
    auto monitor = std::make_shared<performance_monitor>();
    auto logger = std::make_shared<console_logger>();
 
    // Inject monitor into logger
    logger->set_monitor(monitor);
 
    // Log some messages
    logger->log(log_level::info, "First message with monitoring");
    logger->log(log_level::warning, "Second message with monitoring");
    logger->log(log_level::error, "Third message with monitoring");
 
    // Check monitor collected metrics
    auto metrics_result = monitor->get_metrics();
    if (std::holds_alternative<metrics_snapshot>(metrics_result)) {
        auto& snapshot = std::get<metrics_snapshot>(metrics_result);
        std::cout << "\n✓ Monitor collected " << snapshot.metrics.size()
                  << " metrics from logger" << std::endl;
 
        for (const auto& metric : snapshot.metrics) {
            std::cout << "  - " << metric.name << ": " << metric.value << std::endl;
        }
    }
}

References kcenon::monitoring::metric::name, and kcenon::monitoring::metric::value.

Referenced by main().

Here is the caller graph for this function:

demo_monitor_with_logger()

void demo_monitor_with_logger

(

)

Scenario 3: Monitor with Logger Injection (via adapter)

Examples

bidirectional_di_example.cpp.

Definition at line 187 of file bidirectional_di_example.cpp.

                                {
    std::cout << "\n\n=== Scenario 3: Monitor with Logger ===" << std::endl;
    std::cout << "Monitor can report to logger (via adapter pattern).\n" << std::endl;
 
    auto logger = std::make_shared<console_logger>();
    auto monitor = std::make_shared<performance_monitor>();
 
    // Monitor records metrics
    monitor->record_metric("cpu_usage", 45.5);
    monitor->record_metric("memory_usage", 512.0);
 
    // Check health and log result
    auto health_result = monitor->check_health();
    if (std::holds_alternative<health_check_result>(health_result)) {
        auto& health = std::get<health_check_result>(health_result);
        std::string health_msg = "Monitor health: " + to_string(health.status);
        logger->log(log_level::info, health_msg);
    }
 
    std::cout << "\n✓ Monitor can report status to logger" << std::endl;
}

References kcenon::monitoring::to_string().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

demo_runtime_flexibility()

void demo_runtime_flexibility

(

)

Scenario 5: Runtime Flexibility.

Examples

bidirectional_di_example.cpp.

Definition at line 286 of file bidirectional_di_example.cpp.

                                {
    std::cout << "\n\n=== Scenario 5: Runtime Flexibility ===" << std::endl;
    std::cout << "Dependencies can be changed at runtime.\n" << std::endl;
 
    auto logger = std::make_shared<console_logger>();
    auto monitor1 = std::make_shared<performance_monitor>();
    auto monitor2 = std::make_shared<performance_monitor>();
 
    // Start with first monitor
    logger->set_monitor(monitor1);
    logger->log(log_level::info, "Using monitor 1");
 
    // Switch to second monitor
    logger->set_monitor(monitor2);
    logger->log(log_level::info, "Switched to monitor 2");
 
    // Remove monitor completely
    logger->set_monitor(nullptr);
    logger->log(log_level::info, "Operating without monitor");
 
    std::cout << "\n✓ Runtime dependency changes work seamlessly" << std::endl;
}

Referenced by main().

Here is the caller graph for this function:

demo_standalone_systems()

void demo_standalone_systems

(

)

Scenario 1: Standalone Systems.

Examples

bidirectional_di_example.cpp.

Definition at line 136 of file bidirectional_di_example.cpp.

                               {
    std::cout << "\n=== Scenario 1: Standalone Systems ===" << std::endl;
    std::cout << "Both systems work independently without each other.\n" << std::endl;
 
    // Logger works alone
    auto logger = std::make_shared<console_logger>();
    logger->log(log_level::info, "Logger operating standalone");
    std::cout << "✓ Logger works without monitor\n" << std::endl;
 
    // Monitor works alone
    auto monitor = std::make_shared<performance_monitor>();
    auto result = monitor->record_metric("standalone_metric", 42.0);
    if (std::holds_alternative<std::monostate>(result)) {
        std::cout << "✓ Monitor works without logger\n" << std::endl;
    }
}

Referenced by main().

Here is the caller graph for this function:

main()

int main

(

)

Definition at line 309 of file bidirectional_di_example.cpp.

           {
    std::cout << "╔═══════════════════════════════════════════════════════════╗" << std::endl;
    std::cout << "║  Phase 4: Bidirectional DI Example                        ║" << std::endl;
    std::cout << "║  Demonstrating Circular Dependency Resolution             ║" << std::endl;
    std::cout << "╚═══════════════════════════════════════════════════════════╝" << std::endl;
 
    try {
        demo_standalone_systems();
        demo_logger_with_monitor();
        demo_monitor_with_logger();
        demo_bidirectional_integration();
        demo_runtime_flexibility();
 
        std::cout << "\n\n╔═══════════════════════════════════════════════════════════╗" << std::endl;
        std::cout << "║  ✓ ALL SCENARIOS PASSED                                   ║" << std::endl;
        std::cout << "║                                                           ║" << std::endl;
        std::cout << "║  Key Achievement:                                         ║" << std::endl;
        std::cout << "║  • NO compile-time circular dependency                    ║" << std::endl;
        std::cout << "║  • Runtime bidirectional integration works                ║" << std::endl;
        std::cout << "║  • Both systems can operate standalone                    ║" << std::endl;
        std::cout << "║  • Pure interface-based design                            ║" << std::endl;
        std::cout << "╚═══════════════════════════════════════════════════════════╝" << std::endl;
 
        return 0;
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }
}

References demo_bidirectional_integration(), demo_logger_with_monitor(), demo_monitor_with_logger(), demo_runtime_flexibility(), and demo_standalone_systems().

Here is the call graph for this function: