Container integration manager for messaging systems. More...

#include <messaging_integration.h>

Collaboration diagram for kcenon::container::integration::messaging_integration:

Classes
struct	metrics
	Performance metrics collection. More...

Public Types
using	container_callback_t = std::function<void(const std::shared_ptr<value_container>&)>
	External system callback registration.

Static Public Member Functions
static std::shared_ptr< value_container >	create_optimized_container (const std::string &message_type="data_container")
	Container creation with messaging optimization.

static std::string	serialize_for_messaging (const std::shared_ptr< value_container > &container, bool compress=false)
	High-performance serialization for messaging.

static std::shared_ptr< value_container >	deserialize_from_messaging (const std::string &data, bool decompress=false)
	Optimized deserialization for messaging.

static metrics &	get_metrics ()

static void	reset_metrics ()

static std::string	get_metrics_summary ()

static void	register_creation_callback (container_callback_t callback)

static void	register_serialization_callback (container_callback_t callback)

static void	unregister_callbacks ()

Static Private Attributes
static metrics	metrics_

static std::vector< container_callback_t >	creation_callbacks_

static std::vector< container_callback_t >	serialization_callbacks_

static std::mutex	callback_mutex_

Detailed Description

Container integration manager for messaging systems.

Provides enhanced functionality for container operations in messaging environments, including performance monitoring, optimization hints, and external system integration.

Definition at line 31 of file messaging_integration.h.

Member Typedef Documentation

◆ container_callback_t

using kcenon::container::integration::messaging_integration::container_callback_t = std::function<void(const std::shared_ptr<value_container>&)>

External system callback registration.

Definition at line 77 of file messaging_integration.h.

Member Function Documentation

◆ create_optimized_container()

std::shared_ptr< value_container > kcenon::container::integration::messaging_integration::create_optimized_container ( const std::string & message_type = "data_container" )

static

Container creation with messaging optimization.

Definition at line 21 of file messaging_integration.cpp.

                                   {
 
    auto container = std::make_shared<value_container>();
    container->set_message_type(message_type);
 
#ifdef HAS_PERFORMANCE_METRICS
    metrics_.containers_created.fetch_add(1, std::memory_order_relaxed);
#endif
 
#ifdef HAS_EXTERNAL_INTEGRATION
    {
        std::lock_guard<std::mutex> lock(callback_mutex_);
        for (const auto& callback : creation_callbacks_) {
            if (callback) {
                callback(container);
            }
        }
    }
#endif
 
    return container;
}

References callback_mutex_, kcenon::container::integration::messaging_integration::metrics::containers_created, creation_callbacks_, and metrics_.

◆ deserialize_from_messaging()

std::shared_ptr< value_container > kcenon::container::integration::messaging_integration::deserialize_from_messaging	(	const std::string &	data,
		bool	decompress = false )

static

Optimized deserialization for messaging.

Definition at line 86 of file messaging_integration.cpp.

                     {
 
    if (data.empty()) {
        return nullptr;
    }
 
#ifdef HAS_PERFORMANCE_METRICS
    auto start = std::chrono::high_resolution_clock::now();
#endif
 
    std::string processed_data = data;
 
    // TODO: Add decompression support when ENABLE_COMPRESSION is available
    if (decompress) {
        // Placeholder for decompression implementation
    }
 
    auto container = std::make_shared<value_container>(processed_data, false);
 
#ifdef HAS_PERFORMANCE_METRICS
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
    metrics_.deserializations_performed.fetch_add(1, std::memory_order_relaxed);
    metrics_.total_deserialize_time_us.fetch_add(duration.count(), std::memory_order_relaxed);
#endif
 
    return container;
}

References kcenon::container::integration::messaging_integration::metrics::deserializations_performed, metrics_, and kcenon::container::integration::messaging_integration::metrics::total_deserialize_time_us.

◆ get_metrics()

messaging_integration::metrics & kcenon::container::integration::messaging_integration::get_metrics ( )

static

Definition at line 118 of file messaging_integration.cpp.

                                                                 {
    return metrics_;
}

References metrics_.

◆ get_metrics_summary()

std::string kcenon::container::integration::messaging_integration::get_metrics_summary ( )

static

Definition at line 130 of file messaging_integration.cpp.

                                                     {
    std::ostringstream oss;
 
    auto containers = metrics_.containers_created.load(std::memory_order_relaxed);
    auto serializations = metrics_.serializations_performed.load(std::memory_order_relaxed);
    auto deserializations = metrics_.deserializations_performed.load(std::memory_order_relaxed);
    auto serialize_time = metrics_.total_serialize_time_us.load(std::memory_order_relaxed);
    auto deserialize_time = metrics_.total_deserialize_time_us.load(std::memory_order_relaxed);
 
    oss << "Container System Metrics:\n";
    oss << "  Containers created: " << containers << "\n";
    oss << "  Serializations: " << serializations << "\n";
    oss << "  Deserializations: " << deserializations << "\n";
 
    if (serializations > 0) {
        oss << "  Avg serialize time: " << std::fixed << std::setprecision(2)
            << (static_cast<double>(serialize_time) / serializations) << " μs\n";
    }
 
    if (deserializations > 0) {
        oss << "  Avg deserialize time: " << std::fixed << std::setprecision(2)
            << (static_cast<double>(deserialize_time) / deserializations) << " μs\n";
    }
 
    return oss.str();
}

References kcenon::container::integration::messaging_integration::metrics::containers_created, kcenon::container::integration::messaging_integration::metrics::deserializations_performed, metrics_, kcenon::container::integration::messaging_integration::metrics::serializations_performed, kcenon::container::integration::messaging_integration::metrics::total_deserialize_time_us, and kcenon::container::integration::messaging_integration::metrics::total_serialize_time_us.

◆ register_creation_callback()

void kcenon::container::integration::messaging_integration::register_creation_callback ( container_callback_t callback )

static

Definition at line 159 of file messaging_integration.cpp.

                                                                                    {
    std::lock_guard<std::mutex> lock(callback_mutex_);
    creation_callbacks_.push_back(std::move(callback));
}

References callback_mutex_, and creation_callbacks_.

◆ register_serialization_callback()

void kcenon::container::integration::messaging_integration::register_serialization_callback ( container_callback_t callback )

static

Definition at line 164 of file messaging_integration.cpp.

                                                                                         {
    std::lock_guard<std::mutex> lock(callback_mutex_);
    serialization_callbacks_.push_back(std::move(callback));
}

References callback_mutex_, and serialization_callbacks_.

◆ reset_metrics()

void kcenon::container::integration::messaging_integration::reset_metrics ( )

static

Definition at line 122 of file messaging_integration.cpp.

                                          {
    metrics_.containers_created.store(0, std::memory_order_relaxed);
    metrics_.serializations_performed.store(0, std::memory_order_relaxed);
    metrics_.deserializations_performed.store(0, std::memory_order_relaxed);
    metrics_.total_serialize_time_us.store(0, std::memory_order_relaxed);
    metrics_.total_deserialize_time_us.store(0, std::memory_order_relaxed);
}

References kcenon::container::integration::messaging_integration::metrics::containers_created, kcenon::container::integration::messaging_integration::metrics::deserializations_performed, metrics_, kcenon::container::integration::messaging_integration::metrics::serializations_performed, kcenon::container::integration::messaging_integration::metrics::total_deserialize_time_us, and kcenon::container::integration::messaging_integration::metrics::total_serialize_time_us.

◆ serialize_for_messaging()

std::string kcenon::container::integration::messaging_integration::serialize_for_messaging	(	const std::shared_ptr< value_container > &	container,
		bool	compress = false )

static

High-performance serialization for messaging.

Definition at line 45 of file messaging_integration.cpp.

                   {
 
    if (!container) {
        return {};
    }
 
#ifdef HAS_PERFORMANCE_METRICS
    auto start = std::chrono::high_resolution_clock::now();
#endif
 
    auto serialize_result = container->serialize_string(value_container::serialization_format::binary);
    std::string result = serialize_result.is_ok() ? serialize_result.value() : "";
 
    // TODO: Add compression support when ENABLE_COMPRESSION is available
    if (compress) {
        // Placeholder for compression implementation
    }
 
#ifdef HAS_PERFORMANCE_METRICS
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
    metrics_.serializations_performed.fetch_add(1, std::memory_order_relaxed);
    metrics_.total_serialize_time_us.fetch_add(duration.count(), std::memory_order_relaxed);
#endif
 
#ifdef HAS_EXTERNAL_INTEGRATION
    {
        std::lock_guard<std::mutex> lock(callback_mutex_);
        for (const auto& callback : serialization_callbacks_) {
            if (callback) {
                callback(container);
            }
        }
    }
#endif
 
    return result;
}

References callback_mutex_, metrics_, serialization_callbacks_, kcenon::container::integration::messaging_integration::metrics::serializations_performed, and kcenon::container::integration::messaging_integration::metrics::total_serialize_time_us.

◆ unregister_callbacks()

void kcenon::container::integration::messaging_integration::unregister_callbacks ( )

static

Definition at line 169 of file messaging_integration.cpp.

                                                 {
    std::lock_guard<std::mutex> lock(callback_mutex_);
    creation_callbacks_.clear();
    serialization_callbacks_.clear();
}

References callback_mutex_, creation_callbacks_, and serialization_callbacks_.

Member Data Documentation

◆ callback_mutex_

std::mutex kcenon::container::integration::messaging_integration::callback_mutex_

staticprivate

Definition at line 92 of file messaging_integration.h.

Referenced by create_optimized_container(), register_creation_callback(), register_serialization_callback(), serialize_for_messaging(), and unregister_callbacks().

◆ creation_callbacks_

std::vector< messaging_integration::container_callback_t > kcenon::container::integration::messaging_integration::creation_callbacks_

staticprivate

Definition at line 90 of file messaging_integration.h.

Referenced by create_optimized_container(), register_creation_callback(), and unregister_callbacks().

◆ metrics_

messaging_integration::metrics kcenon::container::integration::messaging_integration::metrics_

staticprivate

Definition at line 86 of file messaging_integration.h.

Referenced by create_optimized_container(), deserialize_from_messaging(), get_metrics(), get_metrics_summary(), reset_metrics(), and serialize_for_messaging().

◆ serialization_callbacks_

std::vector< messaging_integration::container_callback_t > kcenon::container::integration::messaging_integration::serialization_callbacks_

staticprivate

Definition at line 91 of file messaging_integration.h.

Referenced by register_serialization_callback(), serialize_for_messaging(), and unregister_callbacks().

The documentation for this class was generated from the following files:

integration/messaging_integration.h
integration/messaging_integration.cpp

Classes

Public Types

Static Public Member Functions

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ container_callback_t

Member Function Documentation

◆ create_optimized_container()

◆ deserialize_from_messaging()

◆ get_metrics()

◆ get_metrics_summary()

◆ register_creation_callback()

◆ register_serialization_callback()

◆ reset_metrics()

◆ serialize_for_messaging()

◆ unregister_callbacks()

Member Data Documentation

◆ callback_mutex_

◆ creation_callbacks_

◆ metrics_

◆ serialization_callbacks_