DataEngine.cpp

#include "DataEngine.h"


std::optional<DataEngine::ExtendedValue> DataEngine::get(const std::string_view name) const
{
    const std::string strName(name);

    const std::shared_lock lock(m_protectData); // read-only lock

    const auto iter = m_data.find(strName);
    if (iter == m_data.cend())
    {
        m_reads.fetch_add(1, std::memory_order_relaxed);
        return {};
    }

    // Potentially we can get small inconsistency while copying different statistics values. It is acceptable.
    const auto reads = iter->second.m_reads.fetch_add(1, std::memory_order_relaxed) + 1;
    const auto writes = iter->second.m_writes.load(std::memory_order_relaxed);

    m_reads.fetch_add(1, std::memory_order_relaxed);

    return { std::move(ExtendedValue{iter->second.m_value, {reads, writes}}) };
}

void DataEngine::initial_set(const std::string_view name, const std::string_view value)
{
    std::string strName(name);

    const std::shared_lock lock(m_protectData); // read-only lock

    const auto iter = m_data.find(strName);
    if (iter == m_data.cend())
    {
        ExtendedValueInternal extended{ std::string(value), 0, 0 };
        m_data.emplace(std::move(strName), std::move(extended));
    }
    else
    {
        iter->second.m_value = value;
    }
}

void DataEngine::set(const std::string_view name, const std::string_view value)
{
    std::string strName(name);

    const std::lock_guard lock(m_protectData); // write lock

    const auto iter = m_data.find(strName);
    if (iter == m_data.cend())
    {
        ExtendedValueInternal extended{ std::string(value), 0, 1 };
        m_data.emplace(std::move(strName), std::move(extended));
    }
    else
    {
        iter->second.m_writes.fetch_add(1, std::memory_order_relaxed);
        iter->second.m_value = value;
    }

    m_writes.fetch_add(1, std::memory_order_relaxed);
}

void DataEngine::enumerate(const std::function<EnumerateVisitorProc>& visitor) const
{
    const std::shared_lock lock(m_protectData); // read-only lock

    for (const auto& name_value : m_data)
    {
        visitor(name_value.first, name_value.second.m_value);
    }
}

DataEngine::AccessStatistics DataEngine::get_global_statistics() const
{
    // No need in full consistency here
    return { m_reads.load(std::memory_order_relaxed), m_writes.load(std::memory_order_relaxed) };
}