Thread-safe container with lock optimization. More...

#include <thread_safe_container.h>

Inheritance diagram for kcenon::container::thread_safe_container:

Collaboration diagram for kcenon::container::thread_safe_container:

Classes
struct	Statistics
	Get statistics. More...

Public Types
using	value_map = std::unordered_map<std::string, value>

using	const_iterator = value_map::const_iterator

using	iterator = value_map::iterator

Public Member Functions
	thread_safe_container ()=default
	Default constructor.

	thread_safe_container (std::initializer_list< std::pair< std::string, value > > init)
	Construct with initial values.

	thread_safe_container (const thread_safe_container &other)
	Copy constructor (thread-safe)

	thread_safe_container (thread_safe_container &&other) noexcept
	Move constructor.

thread_safe_container &	operator= (const thread_safe_container &other)
	Copy assignment (thread-safe)

thread_safe_container &	operator= (thread_safe_container &&other) noexcept
	Move assignment.

std::optional< value >	get (std::string_view key) const
	Get value by key (thread-safe read)

template<concepts::ValueVariantType T>
std::optional< T >	get_typed (std::string_view key) const
	Get typed value by key.

void	set (std::string_view key, value value)
	Set value for key (thread-safe write)

template<concepts::ValueVariantType T>
void	set_typed (std::string_view key, T &&val)
	Set typed value for key.

bool	remove (std::string_view key)
	Remove value by key.

void	clear ()
	Clear all values.

size_t	size () const
	Get the number of values.

bool	empty () const
	Check if container is empty.

bool	contains (std::string_view key) const
	Check if key exists.

std::vector< std::string >	keys () const
	Get all keys.

void	set_variant (const value &val)
	Set a value directly using variant value.

std::optional< value >	get_variant (const std::string &key) const
	Get a value as variant value.

void	set_container (const std::string &key, std::shared_ptr< thread_safe_container > container)
	Set a nested container.

std::shared_ptr< thread_safe_container >	get_container (const std::string &key) const
	Get a nested container.

template<concepts::KeyValueCallback Func>
void	for_each (Func &&func) const
	Apply a function to all values (read-only)

template<concepts::MutableKeyValueCallback Func>
void	for_each_mut (Func &&func)
	Apply a function to all values (mutable)

template<concepts::ValueMapCallback< value_map > Func>
void	bulk_update (Func &&updater)
	Bulk update operation with minimal lock contention.

template<concepts::ConstValueMapCallback< value_map > Func>
auto	bulk_read (Func &&reader) const
	Bulk read operation.

bool	compare_exchange (std::string_view key, const value &expected, const value &desired)
	Atomic compare and swap.

Statistics	get_statistics () const

std::string	to_json () const
	Serialize container to JSON.

std::vector< uint8_t >	serialize () const
	Serialize container to binary.

value &	operator[] (const std::string &key)
	Array-style access (creates if not exists)

std::shared_ptr< lockfree_container_reader >	create_lockfree_reader ()
	Create a lock-free reader for this container.

std::shared_ptr< auto_refresh_reader >	create_auto_refresh_reader (std::chrono::milliseconds refresh_interval)
	Create an auto-refreshing lock-free reader.

Static Public Member Functions
static std::shared_ptr< thread_safe_container >	deserialize (const std::vector< uint8_t > &data)
	Deserialize from binary.

Private Attributes
std::shared_mutex	mutex_

value_map	values_

std::atomic< size_t >	read_count_ {0}

std::atomic< size_t >	write_count_ {0}

std::atomic< size_t >	bulk_read_count_ {0}

std::atomic< size_t >	bulk_write_count_ {0}

Detailed Description

Thread-safe container with lock optimization.

This container provides thread-safe access to variant values with optimized locking strategies for different access patterns.

Definition at line 31 of file thread_safe_container.h.

Member Typedef Documentation

◆ const_iterator

using kcenon::container::thread_safe_container::const_iterator = value_map::const_iterator

Definition at line 35 of file thread_safe_container.h.

◆ iterator

using kcenon::container::thread_safe_container::iterator = value_map::iterator

Definition at line 36 of file thread_safe_container.h.

◆ value_map

using kcenon::container::thread_safe_container::value_map = std::unordered_map<std::string, value>

Definition at line 34 of file thread_safe_container.h.

Constructor & Destructor Documentation

◆ thread_safe_container() [1/4]

kcenon::container::thread_safe_container::thread_safe_container ( )

default

Default constructor.

◆ thread_safe_container() [2/4]

kcenon::container::thread_safe_container::thread_safe_container ( std::initializer_list< std::pair< std::string, value > > init )

Construct with initial values.

Definition at line 14 of file thread_safe_container.cpp.

    {
        for (const auto& [key, value] : init) {
            values_.emplace(key, value);
        }
    }

References values_.

◆ thread_safe_container() [3/4]

kcenon::container::thread_safe_container::thread_safe_container ( const thread_safe_container & other )

Copy constructor (thread-safe)

Definition at line 22 of file thread_safe_container.cpp.

    {
        std::shared_lock other_lock(other.mutex_);
        values_ = other.values_;
        read_count_ = other.read_count_.load();
        write_count_ = other.write_count_.load();
        bulk_read_count_ = other.bulk_read_count_.load();
        bulk_write_count_ = other.bulk_write_count_.load();
    }

References bulk_read_count_, bulk_write_count_, mutex_, read_count_, values_, and write_count_.

◆ thread_safe_container() [4/4]

kcenon::container::thread_safe_container::thread_safe_container ( thread_safe_container && other )

noexcept

Move constructor.

Definition at line 32 of file thread_safe_container.cpp.

    {
        std::unique_lock other_lock(other.mutex_);
        values_ = std::move(other.values_);
        read_count_ = other.read_count_.load();
        write_count_ = other.write_count_.load();
        bulk_read_count_ = other.bulk_read_count_.load();
        bulk_write_count_ = other.bulk_write_count_.load();
        
        other.read_count_ = 0;
        other.write_count_ = 0;
        other.bulk_read_count_ = 0;
        other.bulk_write_count_ = 0;
    }

Member Function Documentation

◆ bulk_read()

template<concepts::ConstValueMapCallback< value_map > Func>

auto kcenon::container::thread_safe_container::bulk_read ( Func && reader ) const

inline

Bulk read operation.

Template Parameters

Func	Function type satisfying ConstValueMapCallback concept

Parameters

reader Function to perform bulk reads

Returns: Result of the reader function

Definition at line 214 of file thread_safe_container.h.

                                            {
            std::shared_lock lock(mutex_);
            bulk_read_count_.fetch_add(1, std::memory_order_relaxed);
            return reader(values_);
        }

References bulk_read_count_, mutex_, and values_.

◆ bulk_update()

template<concepts::ValueMapCallback< value_map > Func>

void kcenon::container::thread_safe_container::bulk_update ( Func && updater )

inline

Bulk update operation with minimal lock contention.

Template Parameters

Func	Function type satisfying ValueMapCallback concept

Parameters

updater Function to perform bulk updates

Definition at line 201 of file thread_safe_container.h.

                                         {
            std::unique_lock lock(mutex_);
            updater(values_);
            bulk_write_count_.fetch_add(1, std::memory_order_relaxed);
        }

References bulk_write_count_, mutex_, and values_.

◆ clear()

void kcenon::container::thread_safe_container::clear ( )

Clear all values.

Definition at line 104 of file thread_safe_container.cpp.

    {
        std::unique_lock lock(mutex_);
        write_count_.fetch_add(1, std::memory_order_relaxed);
        values_.clear();
    }

References mutex_, values_, and write_count_.

◆ compare_exchange()

bool kcenon::container::thread_safe_container::compare_exchange	(	std::string_view	key,
		const value &	expected,
		const value &	desired )

Atomic compare and swap.

Parameters

key	The key to update
expected	The expected current value
desired	The desired new value

Returns: true if swap succeeded, false otherwise

Definition at line 185 of file thread_safe_container.cpp.

    {
        std::unique_lock lock(mutex_);
        write_count_.fetch_add(1, std::memory_order_relaxed);
 
        auto it = values_.find(std::string(key));
        if (it != values_.end()) {
            if (it->second == expected) {
                it->second = desired;
                return true;
            }
        }
        return false;
    }

References mutex_, values_, and write_count_.

◆ contains()

bool kcenon::container::thread_safe_container::contains ( std::string_view key ) const

Check if key exists.

Definition at line 123 of file thread_safe_container.cpp.

    {
        std::shared_lock lock(mutex_);
        read_count_.fetch_add(1, std::memory_order_relaxed);
        return values_.find(std::string(key)) != values_.end();
    }

References mutex_, read_count_, and values_.

◆ create_auto_refresh_reader()

std::shared_ptr< auto_refresh_reader > kcenon::container::thread_safe_container::create_auto_refresh_reader ( std::chrono::milliseconds refresh_interval )

inline

Create an auto-refreshing lock-free reader.

The returned reader automatically refreshes its snapshot at the specified interval using a background thread. This is useful for scenarios where you want lock-free reads with automatic updates without managing the refresh manually.

Parameters

refresh_interval The interval between automatic refreshes

Returns: Shared pointer to a new auto-refresh reader

auto container = std::make_shared<thread_safe_container>();
auto reader = container->create_auto_refresh_reader(std::chrono::milliseconds(100));
 
// Lock-free reads are always up-to-date within refresh_interval
auto value = reader->get<int>("counter");

Definition at line 802 of file thread_safe_container.h.

                                                {
        return std::make_shared<auto_refresh_reader>(shared_from_this(), refresh_interval);
    }

◆ create_lockfree_reader()

std::shared_ptr< lockfree_container_reader > kcenon::container::thread_safe_container::create_lockfree_reader ( )

inline

Create a lock-free reader for this container.

The returned reader provides truly lock-free reads using the RCU pattern. Call refresh() on the reader periodically to update its snapshot.

Returns: Shared pointer to a new lock-free reader

Definition at line 797 of file thread_safe_container.h.

                                                                                                  {
        return std::make_shared<lockfree_container_reader>(shared_from_this());
    }

◆ deserialize()

std::shared_ptr< thread_safe_container > kcenon::container::thread_safe_container::deserialize ( const std::vector< uint8_t > & data )

static

Deserialize from binary.

Definition at line 282 of file thread_safe_container.cpp.

    {
        if (data.size() < sizeof(uint32_t)) {
            return nullptr;
        }
        
        auto container = std::make_shared<thread_safe_container>();
        size_t offset = 0;
        
        // Read number of entries
        uint32_t count;
        std::memcpy(&count, data.data() + offset, sizeof(count));
        offset += sizeof(count);
        
        // Read each key-value pair
        for (uint32_t i = 0; i < count; ++i) {
            if (offset + sizeof(uint32_t) > data.size()) {
                return nullptr;
            }
            
            // Read key
            uint32_t key_len;
            std::memcpy(&key_len, data.data() + offset, sizeof(key_len));
            offset += sizeof(key_len);
            
            if (offset + key_len + sizeof(uint32_t) > data.size()) {
                return nullptr;
            }
            
            std::string key(data.begin() + offset, data.begin() + offset + key_len);
            offset += key_len;
            
            // Read value length
            uint32_t value_len;
            std::memcpy(&value_len, data.data() + offset, sizeof(value_len));
            offset += sizeof(value_len);
            
            if (offset + value_len > data.size()) {
                return nullptr;
            }
            
            // Deserialize value
            std::vector<uint8_t> value_data(data.begin() + offset,
                                           data.begin() + offset + value_len);
            offset += value_len;
 
            auto value_opt = value::deserialize(value_data);
            if (value_opt) {
                container->values_[key] = std::move(*value_opt);
            }
        }
        
        return container;
    }

References kcenon::container::value::deserialize().

Referenced by kcenon::container::value::deserialize_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ empty()

bool kcenon::container::thread_safe_container::empty ( ) const

Check if container is empty.

Definition at line 117 of file thread_safe_container.cpp.

    {
        std::shared_lock lock(mutex_);
        return values_.empty();
    }

References mutex_, and values_.

◆ for_each()

template<concepts::KeyValueCallback Func>

void kcenon::container::thread_safe_container::for_each ( Func && func ) const

inline

Apply a function to all values (read-only)

Template Parameters

Func	Function type satisfying KeyValueCallback concept

Parameters

func	Function to apply to each key-value pair

Definition at line 175 of file thread_safe_container.h.

                                         {
            std::shared_lock lock(mutex_);
            for (const auto& [key, val] : values_) {
                func(key, val);
            }
        }

References mutex_, and values_.

◆ for_each_mut()

template<concepts::MutableKeyValueCallback Func>

void kcenon::container::thread_safe_container::for_each_mut ( Func && func )

inline

Apply a function to all values (mutable)

Template Parameters

Func	Function type satisfying MutableKeyValueCallback concept

Parameters

func	Function to apply to each key-value pair

Definition at line 188 of file thread_safe_container.h.

                                       {
            std::unique_lock lock(mutex_);
            for (auto& [key, val] : values_) {
                func(key, val);
            }
        }

References mutex_, and values_.

◆ get()

std::optional< value > kcenon::container::thread_safe_container::get ( std::string_view key ) const

Get value by key (thread-safe read)

Parameters

key	The key to look up

Returns: Optional containing the value if found

Definition at line 71 of file thread_safe_container.cpp.

    {
        std::shared_lock lock(mutex_);
        read_count_.fetch_add(1, std::memory_order_relaxed);
 
        auto it = values_.find(std::string(key));
        if (it != values_.end()) {
            return it->second;
        }
        return std::nullopt;
    }

References mutex_, read_count_, and values_.

◆ get_container()

std::shared_ptr< thread_safe_container > kcenon::container::thread_safe_container::get_container ( const std::string & key ) const

Get a nested container.

Parameters

key	The key to look up

Returns: Shared pointer to container, nullptr if not found or not a container

Definition at line 172 of file thread_safe_container.cpp.

    {
        std::shared_lock lock(mutex_);
        read_count_.fetch_add(1, std::memory_order_relaxed);
 
        auto it = values_.find(key);
        if (it != values_.end()) {
            return it->second.get<std::shared_ptr<thread_safe_container>>().value_or(nullptr);
        }
        return nullptr;
    }

References mutex_, read_count_, and values_.

◆ get_statistics()

thread_safe_container::Statistics kcenon::container::thread_safe_container::get_statistics ( ) const

Definition at line 202 of file thread_safe_container.cpp.

    {
        std::shared_lock lock(mutex_);
        return {
            read_count_.load(std::memory_order_relaxed),
            write_count_.load(std::memory_order_relaxed),
            bulk_read_count_.load(std::memory_order_relaxed),
            bulk_write_count_.load(std::memory_order_relaxed),
            values_.size()
        };
    }

References bulk_read_count_, bulk_write_count_, mutex_, read_count_, values_, and write_count_.

◆ get_typed()

template<concepts::ValueVariantType T>

std::optional< T > kcenon::container::thread_safe_container::get_typed ( std::string_view key ) const

inline

Get typed value by key.

Template Parameters

T	The expected type (must be a valid variant type)

Parameters

key	The key to look up

Returns: Optional containing the value if found and type matches

Definition at line 82 of file thread_safe_container.h.

                                                           {
            std::shared_lock lock(mutex_);
            auto it = values_.find(std::string(key));
            if (it != values_.end()) {
                return it->second.get<T>();
            }
            return std::nullopt;
        }

References mutex_, and values_.

◆ get_variant()

std::optional< value > kcenon::container::thread_safe_container::get_variant ( const std::string & key ) const

Get a value as variant value.

Parameters

key	The key to look up

Returns: Optional containing the value if found

Definition at line 152 of file thread_safe_container.cpp.

    {
        std::shared_lock lock(mutex_);
        read_count_.fetch_add(1, std::memory_order_relaxed);
 
        auto it = values_.find(key);
        if (it != values_.end()) {
            return it->second;
        }
        return std::nullopt;
    }

References mutex_, read_count_, and values_.

◆ keys()

std::vector< std::string > kcenon::container::thread_safe_container::keys ( ) const

Get all keys.

Definition at line 130 of file thread_safe_container.cpp.

    {
        std::shared_lock lock(mutex_);
        read_count_.fetch_add(1, std::memory_order_relaxed);
 
        std::vector<std::string> result;
        result.reserve(values_.size());
 
        for (const auto& [key, value] : values_) {
            result.push_back(key);
        }
 
        return result;
    }

References mutex_, read_count_, and values_.

◆ operator=() [1/2]

thread_safe_container & kcenon::container::thread_safe_container::operator= ( const thread_safe_container & other )

Copy assignment (thread-safe)

Definition at line 47 of file thread_safe_container.cpp.

    {
        if (this != &other) {
            // Acquire both locks atomically to prevent deadlock
            // std::scoped_lock ensures locks are acquired in a consistent order
            std::scoped_lock lock(mutex_, other.mutex_);
            values_ = other.values_;
            write_count_.fetch_add(1, std::memory_order_relaxed);
        }
        return *this;
    }

References mutex_, values_, and write_count_.

◆ operator=() [2/2]

thread_safe_container & kcenon::container::thread_safe_container::operator= ( thread_safe_container && other )

noexcept

Move assignment.

Definition at line 59 of file thread_safe_container.cpp.

    {
        if (this != &other) {
            // Acquire both locks atomically to prevent deadlock
            // std::scoped_lock ensures locks are acquired in a consistent order
            std::scoped_lock lock(mutex_, other.mutex_);
            values_ = std::move(other.values_);
            write_count_.fetch_add(1, std::memory_order_relaxed);
        }
        return *this;
    }

◆ operator[]()

value & kcenon::container::thread_safe_container::operator[] ( const std::string & key )

Array-style access (creates if not exists)

Definition at line 338 of file thread_safe_container.cpp.

    {
        std::unique_lock lock(mutex_);
        write_count_.fetch_add(1, std::memory_order_relaxed);
 
        auto it = values_.find(key);
        if (it == values_.end()) {
            auto [new_it, inserted] = values_.emplace(key, value(key));
            return new_it->second;
        }
        return it->second;
    }

References mutex_, values_, and write_count_.

◆ remove()

bool kcenon::container::thread_safe_container::remove ( std::string_view key )

Remove value by key.

Parameters

key	The key to remove

Returns: true if removed, false if not found

Definition at line 91 of file thread_safe_container.cpp.

    {
        std::unique_lock lock(mutex_);
        write_count_.fetch_add(1, std::memory_order_relaxed);
        
        auto it = values_.find(std::string(key));
        if (it != values_.end()) {
            values_.erase(it);
            return true;
        }
        return false;
    }

References mutex_, values_, and write_count_.

◆ serialize()

std::vector< uint8_t > kcenon::container::thread_safe_container::serialize ( ) const

Serialize container to binary.

Definition at line 248 of file thread_safe_container.cpp.

    {
        std::shared_lock lock(mutex_);
        read_count_.fetch_add(1, std::memory_order_relaxed);
        
        std::vector<uint8_t> result;
        
        // Header: number of entries (4 bytes)
        uint32_t count = static_cast<uint32_t>(values_.size());
        result.insert(result.end(),
                     reinterpret_cast<const uint8_t*>(&count),
                     reinterpret_cast<const uint8_t*>(&count) + sizeof(count));
        
        // Serialize each key-value pair
        for (const auto& [key, value] : values_) {
            // Key length and key
            uint32_t key_len = static_cast<uint32_t>(key.size());
            result.insert(result.end(),
                         reinterpret_cast<const uint8_t*>(&key_len),
                         reinterpret_cast<const uint8_t*>(&key_len) + sizeof(key_len));
            result.insert(result.end(), key.begin(), key.end());
            
            // Value serialization
            auto value_data = value.serialize();
            uint32_t value_len = static_cast<uint32_t>(value_data.size());
            result.insert(result.end(),
                         reinterpret_cast<const uint8_t*>(&value_len),
                         reinterpret_cast<const uint8_t*>(&value_len) + sizeof(value_len));
            result.insert(result.end(), value_data.begin(), value_data.end());
        }
        
        return result;
    }

References mutex_, read_count_, kcenon::container::value::serialize(), and values_.

Here is the call graph for this function:

◆ set()

void kcenon::container::thread_safe_container::set	(	std::string_view	key,
		value	value )

Set value for key (thread-safe write)

Parameters

key	The key to set
value	The value to store

Definition at line 83 of file thread_safe_container.cpp.

    {
        std::unique_lock lock(mutex_);
        write_count_.fetch_add(1, std::memory_order_relaxed);
 
        values_[std::string(key)] = std::move(value);
    }

References mutex_, values_, and write_count_.

Referenced by set_typed().

Here is the caller graph for this function:

◆ set_container()

void kcenon::container::thread_safe_container::set_container	(	const std::string &	key,
		std::shared_ptr< thread_safe_container >	container )

Set a nested container.

Parameters

key	The key for the nested container
container	The container to store

Definition at line 164 of file thread_safe_container.cpp.

    {
        std::unique_lock lock(mutex_);
        write_count_.fetch_add(1, std::memory_order_relaxed);
        values_[key] = value(key, std::move(container));
    }

References mutex_, values_, and write_count_.

◆ set_typed()

template<concepts::ValueVariantType T>

void kcenon::container::thread_safe_container::set_typed	(	std::string_view	key,
		T &&	val )

inline

Set typed value for key.

Template Parameters

T	The value type (must be a valid variant type)

Parameters

key	The key to set
value	The value to store

Definition at line 105 of file thread_safe_container.h.

                                                    {
            set(key, value(key, std::forward<T>(val)));
        }

References set().

Here is the call graph for this function:

◆ set_variant()

void kcenon::container::thread_safe_container::set_variant ( const value & val )

Set a value directly using variant value.

Parameters

val	The value to store (key is extracted from value's name)

Definition at line 145 of file thread_safe_container.cpp.

    {
        std::unique_lock lock(mutex_);
        write_count_.fetch_add(1, std::memory_order_relaxed);
        values_[std::string(val.name())] = val;
    }

References mutex_, kcenon::container::value::name(), values_, and write_count_.

Here is the call graph for this function:

◆ size()

size_t kcenon::container::thread_safe_container::size ( ) const

Get the number of values.

Definition at line 111 of file thread_safe_container.cpp.

    {
        std::shared_lock lock(mutex_);
        return values_.size();
    }

References mutex_, and values_.

◆ to_json()

std::string kcenon::container::thread_safe_container::to_json ( ) const

Serialize container to JSON.

Definition at line 214 of file thread_safe_container.cpp.

    {
        std::shared_lock lock(mutex_);
        read_count_.fetch_add(1, std::memory_order_relaxed);
        
        std::string result = "{";
        bool first = true;
        
        for (const auto& [key, value] : values_) {
            if (!first) {
                result += ",";
            }
            first = false;
            
            // Escape key for JSON
            result += "\"";
            for (char c : key) {
                switch (c) {
                    case '"': result += "\\\""; break;
                    case '\\': result += "\\\\"; break;
                    case '\n': result += "\\n"; break;
                    case '\r': result += "\\r"; break;
                    case '\t': result += "\\t"; break;
                    default: result += c;
                }
            }
            result += "\":";
            result += value.to_json();
        }
        
        result += "}";
        return result;
    }

References mutex_, read_count_, kcenon::container::value::to_json(), and values_.

Here is the call graph for this function:

Member Data Documentation

◆ bulk_read_count_

std::atomic<size_t> kcenon::container::thread_safe_container::bulk_read_count_ {0}

mutableprivate

Definition at line 303 of file thread_safe_container.h.

303{0};

Referenced by bulk_read(), get_statistics(), and thread_safe_container().

◆ bulk_write_count_

std::atomic<size_t> kcenon::container::thread_safe_container::bulk_write_count_ {0}

mutableprivate

Definition at line 304 of file thread_safe_container.h.

304{0};

Referenced by bulk_update(), get_statistics(), and thread_safe_container().

◆ mutex_

std::shared_mutex kcenon::container::thread_safe_container::mutex_

mutableprivate

Definition at line 297 of file thread_safe_container.h.

Referenced by bulk_read(), bulk_update(), clear(), compare_exchange(), contains(), empty(), for_each(), for_each_mut(), get(), get_container(), get_statistics(), get_typed(), get_variant(), keys(), operator=(), operator[](), remove(), serialize(), set(), set_container(), set_variant(), size(), thread_safe_container(), and to_json().

◆ read_count_

std::atomic<size_t> kcenon::container::thread_safe_container::read_count_ {0}

mutableprivate

Definition at line 301 of file thread_safe_container.h.

301{0};

Referenced by contains(), get(), get_container(), get_statistics(), get_variant(), keys(), serialize(), thread_safe_container(), and to_json().

◆ values_

value_map kcenon::container::thread_safe_container::values_

private

Definition at line 298 of file thread_safe_container.h.

Referenced by bulk_read(), bulk_update(), clear(), compare_exchange(), contains(), empty(), for_each(), for_each_mut(), get(), get_container(), get_statistics(), get_typed(), get_variant(), keys(), operator=(), operator[](), remove(), serialize(), set(), set_container(), set_variant(), size(), thread_safe_container(), thread_safe_container(), and to_json().

◆ write_count_

std::atomic<size_t> kcenon::container::thread_safe_container::write_count_ {0}

mutableprivate

Definition at line 302 of file thread_safe_container.h.

302{0};

Referenced by clear(), compare_exchange(), get_statistics(), operator=(), operator[](), remove(), set(), set_container(), set_variant(), and thread_safe_container().

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

internal/thread_safe_container.h
internal/thread_safe_container.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ const_iterator

◆ iterator

◆ value_map

Constructor & Destructor Documentation

◆ thread_safe_container() [1/4]

◆ thread_safe_container() [2/4]

◆ thread_safe_container() [3/4]

◆ thread_safe_container() [4/4]

Member Function Documentation

◆ bulk_read()

◆ bulk_update()

◆ clear()

◆ compare_exchange()

◆ contains()

◆ create_auto_refresh_reader()

◆ create_lockfree_reader()

◆ deserialize()

◆ empty()

◆ for_each()

◆ for_each_mut()

◆ get()

◆ get_container()

◆ get_statistics()

◆ get_typed()

◆ get_variant()

◆ keys()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator[]()

◆ remove()

◆ serialize()

◆ set()

◆ set_container()

◆ set_typed()

◆ set_variant()

◆ size()

◆ to_json()

Member Data Documentation

◆ bulk_read_count_

◆ bulk_write_count_

◆ mutex_

◆ read_count_

◆ values_

◆ write_count_