Snapshot-based reader for frequently accessed data. More...

#include <thread_safe_container.h>

Collaboration diagram for kcenon::container::snapshot_reader:

Public Types
using	snapshot_ptr = std::shared_ptr<const thread_safe_container::value_map>

Public Member Functions
	snapshot_reader (std::shared_ptr< thread_safe_container > container)

template<concepts::ValueVariantType T>
std::optional< T >	get (std::string_view key) const
	Get value from snapshot (lock-protected read of snapshot)

void	update_snapshot ()
	Update snapshot from container.

Private Attributes
std::shared_ptr< thread_safe_container >	container_

snapshot_ptr	snapshot_

std::shared_mutex	snapshot_mutex_

Detailed Description

Snapshot-based reader for frequently accessed data.

Uses a snapshot pattern to provide read access with reduced lock contention. Note: This is not truly lock-free, as it uses a shared_mutex internally. The snapshot is updated explicitly, allowing multiple reads without acquiring the main container lock. This is useful for read-heavy workloads where slightly stale data is acceptable.

Definition at line 316 of file thread_safe_container.h.

Member Typedef Documentation

◆ snapshot_ptr

using kcenon::container::snapshot_reader::snapshot_ptr = std::shared_ptr<const thread_safe_container::value_map>

Definition at line 318 of file thread_safe_container.h.

Constructor & Destructor Documentation

◆ snapshot_reader()

kcenon::container::snapshot_reader::snapshot_reader ( std::shared_ptr< thread_safe_container > container )

inlineexplicit

Definition at line 320 of file thread_safe_container.h.

            : container_(container) {
            update_snapshot();
        }

References update_snapshot().

Here is the call graph for this function:

Member Function Documentation

◆ get()

template<concepts::ValueVariantType T>

std::optional< T > kcenon::container::snapshot_reader::get ( std::string_view key ) const

inline

Get value from snapshot (lock-protected read of snapshot)

Template Parameters

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

Note: The snapshot may be stale; call update_snapshot() to refresh

Definition at line 331 of file thread_safe_container.h.

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

References snapshot_, and snapshot_mutex_.

◆ update_snapshot()

void kcenon::container::snapshot_reader::update_snapshot ( )

Update snapshot from container.

Note: This acquires the container's lock and should be called periodically

Definition at line 352 of file thread_safe_container.cpp.

    {
        auto new_snapshot = std::make_shared<thread_safe_container::value_map>(
            container_->bulk_read([](const auto& map) { return map; })
        );
 
        std::unique_lock lock(snapshot_mutex_);
        snapshot_ = new_snapshot;
    }