messaging_integration_example.cpp File Reference

Messaging system integration, round-trip serialization, and memory efficiency. More...

#include <iostream>
#include <vector>
#include <chrono>
#include <thread>
#include <iomanip>
#include "container.h"

Include dependency graph for messaging_integration_example.cpp:

Go to the source code of this file.

Functions
void	demonstrate_basic_usage ()
void	demonstrate_value_access ()
void	demonstrate_serialization_roundtrip ()
void	demonstrate_compatibility ()
void	performance_comparison ()
void	demonstrate_memory_efficiency ()
int	main ()

Detailed Description

Messaging system integration, round-trip serialization, and memory efficiency.

Definition in file messaging_integration_example.cpp.

Function Documentation

demonstrate_basic_usage()

void demonstrate_basic_usage

(

)

Definition at line 36 of file messaging_integration_example.cpp.

                               {
    std::cout << "\n=== Basic Container Usage ===\n";
 
    // Create container using set_value API
    auto container = std::make_shared<value_container>();
    container->set_source("client_01", "session_123");
    container->set_target("server", "main_handler");
    container->set_message_type("user_data");
 
    // Add values using set_value
    container->set("user_id", static_cast<int64_t>(12345L));
    container->set("username", std::string("john_doe"));
    container->set("balance", 1500.75);
    container->set("active", true);
 
    std::cout << "Created container with 4 values\n";
    std::cout << "Message type: " << container->message_type() << "\n";
    std::cout << "Source: " << container->source_id() << ":" << container->source_sub_id() << "\n";
    std::cout << "Target: " << container->target_id() << ":" << container->target_sub_id() << "\n";
 
    // Serialize
    std::string serialized = container->serialize_string(value_container::serialization_format::binary).value();
    std::cout << "Serialized size: " << serialized.size() << " bytes\n";
}

Referenced by main().

Here is the caller graph for this function:

demonstrate_compatibility()

void demonstrate_compatibility

(

)

Examples

messaging_integration_example.cpp.

Definition at line 141 of file messaging_integration_example.cpp.

                                 {
    std::cout << "\n=== Messaging System Compatibility ===\n";
 
    // Show that the container system can be used with both aliases
    std::cout << "This container system provides compatibility aliases:\n";
    std::cout << "- ContainerSystem::container (standalone usage)\n";
    std::cout << "- MessagingSystem::container (messaging system integration)\n\n";
 
    // Demonstrate that the same container can be used in different contexts
    auto container = std::make_shared<value_container>();
    container->set_message_type("compatibility_test");
    container->set("demo_value", static_cast<int32_t>(123));
 
    std::cout << "Container can be used standalone or as part of messaging system\n";
    std::cout << "Type safety and performance remain consistent across usage patterns\n";
}

Referenced by main().

Here is the caller graph for this function:

demonstrate_memory_efficiency()

void demonstrate_memory_efficiency

(

)

Examples

messaging_integration_example.cpp.

Definition at line 183 of file messaging_integration_example.cpp.

                                     {
    std::cout << "\n=== Memory Efficiency ===\n";
 
    auto container = std::make_shared<value_container>();
    container->set_message_type("memory_test");
 
    // Add various values
    container->set("small_int", static_cast<int32_t>(42));
    container->set("large_string", std::string(1000, 'x'));
    container->set("double_val", 123.456);
    container->set("bool_val", true);
    container->set("long_val", static_cast<int64_t>(9999999999L));
 
    // Get memory stats
    auto [heap, stack] = container->memory_stats();
    std::cout << "Container memory stats:\n";
    std::cout << "  Heap allocations: " << heap << "\n";
    std::cout << "  Stack allocations: " << stack << "\n";
    std::cout << "  Total footprint: " << container->memory_footprint() << " bytes\n";
}

Referenced by main().

Here is the caller graph for this function:

demonstrate_serialization_roundtrip()

void demonstrate_serialization_roundtrip

(

)

Examples

messaging_integration_example.cpp.

Definition at line 100 of file messaging_integration_example.cpp.

                                           {
    std::cout << "\n=== Serialization Round-trip ===\n";
 
    // Create source container
    auto source = std::make_shared<value_container>();
    source->set_source("sender", "app_1");
    source->set_target("receiver", "app_2");
    source->set_message_type("roundtrip_test");
 
    source->set("int_val", static_cast<int32_t>(42));
    source->set("double_val", 3.14159);
    source->set("string_val", std::string("Hello, World!"));
    source->set("bool_val", true);
    source->set("long_val", static_cast<int64_t>(9876543210L));
 
    // Serialize
    std::string serialized = source->serialize_string(value_container::serialization_format::binary).value();
    std::cout << "Serialized " << source->size() << " values to " << serialized.size() << " bytes\n";
 
    // Deserialize
    auto restored = std::make_shared<value_container>(serialized);
    std::cout << "Restored container: " << restored->message_type() << "\n";
 
    // Verify values
    bool all_match = true;
 
    if (auto val = restored->get("int_val")) {
        if (auto* v = std::get_if<int32_t>(&val->data)) {
            if (*v != 42) all_match = false;
        }
    }
 
    if (auto val = restored->get("string_val")) {
        if (auto* v = std::get_if<std::string>(&val->data)) {
            if (*v != "Hello, World!") all_match = false;
        }
    }
 
    std::cout << "Round-trip verification: " << (all_match ? "PASSED" : "FAILED") << "\n";
}

Referenced by main().

Here is the caller graph for this function:

demonstrate_value_access()

void demonstrate_value_access

(

)

Definition at line 61 of file messaging_integration_example.cpp.

                                {
    std::cout << "\n=== Value Access Patterns ===\n";
 
    auto container = std::make_shared<value_container>();
    container->set_message_type("value_access_demo");
 
    // Add various values
    container->set("request_id", static_cast<int32_t>(789));
    container->set("priority", static_cast<int32_t>(1));
    container->set("payload", std::string("Important data"));
    container->set("timestamp", static_cast<int64_t>(1672531200L));
    container->set("is_urgent", true);
 
    // Access values using get_value and std::get_if
    if (auto val = container->get("request_id")) {
        if (auto* v = std::get_if<int32_t>(&val->data)) {
            std::cout << "Request ID: " << *v << "\n";
        }
    }
 
    if (auto val = container->get("payload")) {
        if (auto* v = std::get_if<std::string>(&val->data)) {
            std::cout << "Payload: " << *v << "\n";
        }
    }
 
    if (auto val = container->get("is_urgent")) {
        if (auto* v = std::get_if<bool>(&val->data)) {
            std::cout << "Is Urgent: " << (*v ? "yes" : "no") << "\n";
        }
    }
 
    // Iterate over all values
    std::cout << "\nAll values in container:\n";
    for (const auto& val : *container) {
        std::cout << "  - " << val.name << " (type: " << static_cast<int>(val.type) << ")\n";
    }
}

Referenced by main().

Here is the caller graph for this function:

main()

int main

(

)

Definition at line 204 of file messaging_integration_example.cpp.

           {
    std::cout << "Container System - Messaging Integration Example\n";
    std::cout << "================================================\n";
    std::cout << "Using variant-based API (set_value/get_value)\n";
 
    try {
        // Demonstrate various features
        demonstrate_basic_usage();
        demonstrate_value_access();
        demonstrate_serialization_roundtrip();
        demonstrate_compatibility();
        performance_comparison();
        demonstrate_memory_efficiency();
 
        std::cout << "\n=== Example Completed Successfully ===\n";
 
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }
 
    return 0;
}

References demonstrate_basic_usage(), demonstrate_compatibility(), demonstrate_memory_efficiency(), demonstrate_serialization_roundtrip(), demonstrate_value_access(), and performance_comparison().

Here is the call graph for this function:

performance_comparison()

void performance_comparison

(

)

Examples

messaging_integration_example.cpp.

Definition at line 158 of file messaging_integration_example.cpp.

                              {
    std::cout << "\n=== Performance Comparison ===\n";
 
    const int iterations = 1000;
 
    // Test set_value performance
    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < iterations; ++i) {
        auto container = std::make_shared<value_container>();
        container->set_message_type("perf_test");
        container->set("index", static_cast<int32_t>(i));
        container->set("data", std::string("test_data"));
        std::string serialized = container->serialize_string(value_container::serialization_format::binary).value();
    }
    auto standard_time = std::chrono::high_resolution_clock::now() - start;
 
    auto standard_ms = std::chrono::duration_cast<std::chrono::milliseconds>(standard_time).count();
    std::cout << "set_value API: " << standard_ms << " ms for " << iterations << " operations\n";
 
    if (standard_ms > 0) {
        double rate = (iterations * 1000.0) / standard_ms;
        std::cout << "Rate: " << std::fixed << std::setprecision(2) << rate << " containers/second\n";
    }
}

Referenced by main().

Here is the caller graph for this function: