| ▼Ncbeam | The root namespace for the Cbeam library. This namespace unifies cross-platform utilities for concurrency, memory management, file handling, logging, serialization, and more. Its purpose is to provide a cohesive collection of modern C++ components that address common system-level and application-level tasks, while promoting thread-safety, interprocess communication, and stable resource handling across varied platform APIs |
| ▼Nconcurrency | Provides concurrency primitives and abstractions for multithreaded programming. It features the powerful message_manager class for managing asynchronous message queues with flexible ordering (FIFO, FILO, or RANDOM), as well as threaded_object, which uses CRTP to encapsulate worker-thread logic with built-in synchronization. These classes simplify threaded operations, interprocess synchronization, and message dispatch under varying concurrency scenarios |
| Cmessage_manager | |
| Cnamed_recursive_mutex | Provides a cross-platform interface for recursive named mutexes, enabling interprocess synchronization |
| CtagTHREADNAME_INFO | |
| ▼Cthreaded_object | |
| Cconstruction_token | |
| ▼Ncontainer | Offers advanced container types with unique approaches to stability and interprocess sharing. Besides standard helpers like buffer and circular_buffer, it includes innovative classes such as stable_interprocess_container and stable_interprocess_map. These support shared-memory usage, ensuring consistent serialization and robust data exchange across process boundaries or differing compiler environments |
| Cbuffer | Manages memory a byte buffer, offering dynamic appending. This class is designed for scenarios where performance and control are crucial, such as in systems with dynamic memory requirements or real-time constraints. It uses malloc and free for efficient resizing of memory blocks without initialization overhead, as it internally uses the plain data type uint8_t |
| Ccircular_buffer | A template class representing a circular buffer |
| Cnested_map | A map structure that can store nested maps of keys and values. By including serialization/nested_map.hpp, it gains serialization capability |
| Cstable_interprocess_container | Manages type-safe, interprocess container operations with stable serialization |
| Cstable_interprocess_map | Provides a type-safe, interprocess map with stable serialization |
| ▼Cstable_reference_buffer | Manages memory buffers with stable reference counting, optimized for shared library contexts |
| Cdelay_deallocation | Manages delayed deallocation of memory blocks in shared library contexts |
| ▼Cthread_safe_container | Base class for thread safe containers |
| Clock_guard | Inner class providing RAII-style locking mechanism |
| Cthread_safe_map | Thread-safe wrapper for std::map |
| Cthread_safe_set | Thread-safe wrapper for std::set |
| ▼Nconvert | Contains conversion utilities to transform data between different formats and types. Functions here handle string conversions, encoding manipulations, and the creation of string representations for various C++ types. They help ensure consistent serialization and text output across the library |
| Chas_insertion_operator | The has_insertion_operator trait provides static meta-information about whether a type T has overloaded the operator<< for insertion into an output stream |
| Chas_insertion_operator< T, std::void_t< decltype(std::declval< std::ostream & >()<< std::declval< T >())> > | |
| Chas_key_and_mapped_type | Type trait to check if a given type supports key_type and mapped_type, similar to std::map |
| Chas_key_and_mapped_type< T, std::void_t< typename T::key_type, typename T::mapped_type > > | |
| Cis_nested_map | Type trait to check if a given type is a nested map |
| Cis_nested_map< T, std::void_t< typename T::nested_tables, typename T::table_of_values > > | |
| ▼Nerror | Defines Cbeam-specific exception types that behave like their standard counterparts. For example, runtime_error and system_error derive from base_error and std::runtime_error (or std::system_error), unifying error handling under a single hierarchy and ensuring consistent cross-platform throw/catch logic |
| Cbase_error | The root class for all Cbeam-specific exceptions, akin to std::exception |
| Clogic_error | A Cbeam-specific logic error that also behaves like std::logic_error |
| Cout_of_range | A Cbeam-specific out_of_range error that also behaves like std::out_of_range |
| Coverflow_error | A Cbeam-specific logic error that also behaves like std::overflow_error |
| Cruntime_error | A Cbeam-specific runtime error that also acts like std::runtime_error |
| Csystem_error | Custom exception class for handling system-level errors in a cross-platform manner |
| ▼Nfilesystem | Facilitates file I/O, path normalization, and directory operations in a cross-platform manner. Its classes and functions simplify reading, writing, creating, or deleting files and directories, handling discrepancies in path formats, symbolic links, and OS-specific peculiarities |
| Cpath | |
| Cstdout_redirector | Class for redirecting stdout to a file and subsequently resetting it to the system's default state |
| ▼Njson | Provides JSON-style and nested-map serialization features. It offers methods to convert a wide range of container types (maps, nested_maps) and strings into JSON-like structures, with an emphasis on composability and integration with other Cbeam utilities. The goal is to offer concise, type-safe serialization for both simple and nested data |
| Cmap_serializer | Provides JSON-style serialization logic for any map type Map |
| Cnested_map_serializer | Generic serializer for nested_map<Key, Value> types |
| Ctraits | Defines the traits required for serializing and deserializing objects of type T |
| Ctraits< cbeam::container::nested_map< Key, Value > > | Specialization of traits for nested_map<Key, Value>, enabling JSON-like serialization |
| Ctraits< const cbeam::container::nested_map< Key, Value > > | |
| Ctraits< const std::map< Key, Value > > | |
| Ctraits< std::map< Key, Value > > | Specialization of traits for std::map<Key, Value>, providing JSON serialization |
| Ctraits< std::string > | Specialization of traits for std::string providing JSON serialization |
| ▼Nlifecycle | Manages the lifecycle of singletons, item registries, and scoped variables. This namespace introduces powerful constructs such as singleton_control and item_registry for explicitly managing the instantiation and teardown of resources, minimizing global-state risks and encouraging well-defined initialization flows |
| Cextract_atomic_value_type | Extracts the underlying value type T from either T or std::atomic<T> |
| Cextract_atomic_value_type< std::atomic< T > > | |
| Citem_registry | Manages the registration and deregistration of items with unique identifiers |
| Cscoped_set | A helper that sets the given variable to a new value, and restores the original value on destruction |
| Csingleton | |
| Csingleton_control | Base class for controlling the lifecycle of all singleton instances across different types |
| ▼Nlogging | Offers flexible logging mechanisms to record messages with timestamps and thread information. The log_manager can create or reinitialize log files at runtime, appending text from multiple threads safely, while log handles file writes with concurrency considerations. Debug-logging macros are also provided for conditional compilation |
| Clog | The log class provides basic file-based logging functionality |
| Clog_manager | The log_manager class provides a global logging facility that can be used throughout the application |
| Clogger | |
| ▼Nmemory | Houses abstractions for shared-memory and interprocess data exchange. This includes interprocess_shared_memory for OS-level memory segments and unified resource sharing, along with helper classes in other namespaces. It highlights stable reference counting and safe pointer conversions for robust cross-process operations |
| ▼Cinterprocess_shared_memory | Provides a unified, platform-independent interface for managing shared memory segments |
| Clock_guard | |
| Cpointer | The pointer class is one of the types supported by container::xpod::type |
| ▼Nplatform | Groups platform-specific helpers for Windows, Linux, and macOS. These utilities detect CPU architecture, manage COM initialization on Windows, resolve runtime paths, handle system directories, and unify OS-level functionality behind well-defined C++ APIs |
| Ccom_initializer | Manages the initialization and deinitialization of COM |
| ▼Nserialization | Implements traits-based serialization for complex data types, including standard containers and custom structures. It relies on specialized traits and buffer logic to convert objects to and from raw memory blocks, enabling stable interprocess data transport and straightforward integration with advanced container classes and xpod variants |
| Cmap_serializer | Provides serialization and deserialization logic for standard map-like containers |
| Cnested_map_serializer | Provides serialization and deserialization logic for nested_map<Key, Value> |
| Ctraits | Defines the traits required for serializing and deserializing objects of type T |
| Ctraits< cbeam::container::nested_map< Key, Value > > | Specialization of traits for cbeam::container::nested_map<Key, Value> |
| Ctraits< const cbeam::container::nested_map< Key, Value > > | Specialization of traits for const cbeam::container::nested_map<Key, Value> supporting serialization only |
| Ctraits< const std::map< Key, Value > > | Specialization of traits for const std::map<Key, Value> supporting serialization only |
| Ctraits< container::xpod::type > | Specialization of traits for cbeam::container::xpod::type |
| Ctraits< std::map< Key, Value > > | Specialization of traits for std::map<Key, Value> providing serialization/deserialization |
| Ctraits< std::string > | Specialization of traits for std::string, providing both serialization and deserialization |
| CConvertNestedMapXpodTest | |
| CJSONTest | |
| CMessageManagerTest | |
| CSerializableMapTest | |
| CSerializableNestedMapTest | |
| CSerialization | |
| CSingletonTest | |
| Cstable_interprocess_map | Provides a type-safe, interprocess map with stable serialization |
| CStableInterprocessMapTest | |
| CStableReferenceBufferTest | |
| CTestClass | |
| CTestThreadedObject | |
1.13.2