adapter_pattern_poc.cpp File Reference

Proof-of-concept for adapter pattern refactoring. More...

#include <iostream>
#include <memory>
#include <string>
#include <chrono>

Include dependency graph for adapter_pattern_poc.cpp:

Go to the source code of this file.

Classes
class	logger_old
class	logger_core
class	logger_adapter
class	standalone_adapter
class	external_system_interface
class	thread_system_adapter
class	common_system_interface
class	common_system_adapter
class	full_integration_adapter
class	logger_factory

Enumerations
enum class	integration_mode { standalone , thread_system , common_system , full }

Functions
void	demonstrate_adapters ()
void	benchmark_overhead ()
int	main ()

Detailed Description

Proof-of-concept for adapter pattern refactoring.

Definition in file adapter_pattern_poc.cpp.

Enumeration Type Documentation

integration_mode

enum class integration_mode

strong

Enumerator
standalone
thread_system
common_system
full

Definition at line 204 of file adapter_pattern_poc.cpp.

                            {
    standalone,
    thread_system,
    common_system,
    full
};

Function Documentation

benchmark_overhead()

void benchmark_overhead

(

)

Examples

adapter_pattern_poc.cpp.

Definition at line 307 of file adapter_pattern_poc.cpp.

                          {
    std::cout << "\n=== Performance Comparison ===\n" << std::endl;
 
    const int iterations = 1000000;
    auto core = std::make_shared<logger_core>();
 
    // Direct call (no virtual)
    {
        auto start = std::chrono::high_resolution_clock::now();
        for (int i = 0; i < iterations; ++i) {
            core->log_internal("test");
        }
        auto end = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start);
        std::cout << "Direct call: " << duration.count() / iterations << " ns/call" << std::endl;
    }
 
    // Virtual call through adapter
    {
        auto adapter = std::make_unique<standalone_adapter>(core);
        auto start = std::chrono::high_resolution_clock::now();
        for (int i = 0; i < iterations; ++i) {
            adapter->log("test");
        }
        auto end = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start);
        std::cout << "Virtual call: " << duration.count() / iterations << " ns/call" << std::endl;
        std::cout << "Overhead: ~1-2ns (negligible for I/O operations)" << std::endl;
    }
}

Referenced by main().

Here is the caller graph for this function:

demonstrate_adapters()

void demonstrate_adapters

(

)

Examples

adapter_pattern_poc.cpp.

Definition at line 239 of file adapter_pattern_poc.cpp.

                            {
    std::cout << "\n=== Adapter Pattern Proof of Concept ===\n" << std::endl;
 
    // Test 1: Standalone mode
    {
        std::cout << "Test 1: Standalone Mode" << std::endl;
        auto logger = logger_factory::create(integration_mode::standalone);
        logger->log("Hello from standalone mode");
        std::cout << "Messages logged: " << logger->message_count() << "\n" << std::endl;
    }
 
    // Test 2: Thread system integration
    {
        std::cout << "Test 2: Thread System Integration" << std::endl;
        auto logger = logger_factory::create(integration_mode::thread_system);
 
        // Can use as logger_adapter
        logger->log("Hello as adapter");
 
        // Can cast to external interface
        auto* external = dynamic_cast<external_system_interface*>(logger.get());
        if (external) {
            external->external_log("Hello via external interface");
            std::cout << "Interface: " << external->get_interface_name() << std::endl;
        }
        std::cout << std::endl;
    }
 
    // Test 3: Common system integration
    {
        std::cout << "Test 3: Common System Integration" << std::endl;
        auto logger = logger_factory::create(integration_mode::common_system);
 
        auto* monitored = dynamic_cast<common_system_interface*>(logger.get());
        if (monitored) {
            monitored->monitored_log("Message 1");
            monitored->monitored_log("Message 2");
            std::cout << "Metrics collected: " << monitored->get_metric_count() << std::endl;
        }
        std::cout << std::endl;
    }
 
    // Test 4: Full integration (both interfaces)
    {
        std::cout << "Test 4: Full Integration" << std::endl;
        auto logger = logger_factory::create(integration_mode::full);
 
        // Use both interfaces
        auto* external = dynamic_cast<external_system_interface*>(logger.get());
        auto* monitored = dynamic_cast<common_system_interface*>(logger.get());
 
        if (external && monitored) {
            external->external_log("Via external interface");
            monitored->monitored_log("Via monitoring interface");
            std::cout << "Total messages: " << monitored->get_metric_count() << std::endl;
        }
        std::cout << std::endl;
    }
 
    // Test 5: Runtime mode switching (same binary!)
    {
        std::cout << "Test 5: Runtime Mode Switching" << std::endl;
        std::cout << "All modes tested with SINGLE BINARY" << std::endl;
        std::cout << "No recompilation needed!" << std::endl;
    }
}

References common_system, logger_factory::create(), full, standalone, and thread_system.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main

(

)

Examples

adapter_pattern_poc.cpp, advanced_features_demo.cpp, basic_usage.cpp, composite_writer_example.cpp, crash_protection/main.cpp, critical_logging_example.cpp, custom_writer_example.cpp, decorator_usage.cpp, di_pattern_example.cpp, distributed_logging_demo.cpp, logger_config_builder_example.cpp, metrics_demo.cpp, monitoring_integration_example.cpp, security_demo.cpp, structured_logging_example.cpp, and writer_builder_example.cpp.

Definition at line 338 of file adapter_pattern_poc.cpp.

           {
    demonstrate_adapters();
    benchmark_overhead();
 
    std::cout << "\n=== Benefits Summary ===" << std::endl;
    std::cout << "✅ Single binary for all modes" << std::endl;
    std::cout << "✅ Runtime mode selection" << std::endl;
    std::cout << "✅ Easier testing (no recompilation)" << std::endl;
    std::cout << "✅ Clear code structure" << std::endl;
    std::cout << "✅ Minimal performance overhead" << std::endl;
    std::cout << "✅ Better maintainability" << std::endl;
 
    return 0;
}

References benchmark_overhead(), and demonstrate_adapters().

Here is the call graph for this function: