thread_safe_map.hpp

Go to the documentation of this file.

/*
Copyright (c) 2025 acrion innovations GmbH
Authors: Stefan Zipproth, s.zipproth@acrion.ch
 
This file is part of Cbeam, see https://github.com/acrion/cbeam and https://cbeam.org
 
Cbeam is offered under a commercial and under the AGPL license.
For commercial licensing, contact us at https://acrion.ch/sales. For AGPL licensing, see below.
 
AGPL licensing:
 
Cbeam is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
 
Cbeam is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
 
You should have received a copy of the GNU Affero General Public License
along with Cbeam. If not, see <https://www.gnu.org/licenses/>.
*/
 
#pragma once
 
#include <cbeam/container/thread_safe_container.hpp>
#include <cbeam/error/out_of_range.hpp>   // for cbeam::error::out_of_range
#include <cbeam/error/runtime_error.hpp>  // for cbeam::error::runtime_error
#include <cbeam/lifecycle/scoped_set.hpp> // for cbeam::lifecycle::scoped_set
 
#include <cassert>   // for assert
#include <stdexcept> // for std::out_of_range
#include <cstddef>   // for std::size_t
 
#include <atomic>    // for std::atomic
#include <map>       // for std::map
#include <mutex>     // for std::recursive_mutex, std::lock_guard
#include <string>    // for std::string, std::allocator
#include <utility>   // for std::pair
 
namespace cbeam::container
{
    template <typename Key, typename Value>
    class thread_safe_map : public thread_safe_container<std::map<Key, Value>>
    {
    public:
        Value& at(const Key& key, const std::string& what_arg = "Key not found")
        {
            std::lock_guard<std::recursive_mutex> lock(this->_mutex);
            if (this->_is_being_modified)
            {
                throw cbeam::error::runtime_error("cbeam::container::thread_safe_map::at: not allowed during destruction of the map.");
            }
 
            try
            {
                return this->_container.at(key);
            }
            catch (const std::out_of_range&)
            {
                throw cbeam::error::out_of_range(what_arg);
            }
        }

        auto find(const Key& key, const std::string& what_arg = {})
        {
            std::lock_guard<std::recursive_mutex> lock(this->_mutex);
            if (this->_is_being_modified)
            {
                throw cbeam::error::runtime_error("cbeam::container::thread_safe_map::find: not allowed during modification of the map.");
            }
            auto it = this->_container.find(key);
            if (!what_arg.empty() && it == this->_container.end())
            {
                throw cbeam::error::out_of_range(what_arg);
            }
            return it;
        }

        Value& operator[](const Key& key)
        {
            std::lock_guard<std::recursive_mutex> lock(this->_mutex);
            if (this->_is_being_modified)
            {
                throw cbeam::error::runtime_error("cbeam::container::thread_safe_map::operator[]: not allowed during modification of the map.");
            }
            return this->_container[key];
        }

        std::size_t erase(const Key& key)
        {
            std::lock_guard<std::recursive_mutex> lock(this->_mutex);
            if (this->_is_being_modified)
            {
                throw cbeam::error::runtime_error("cbeam::container::thread_safe_map::erase: not allowed during modification of the map.");
            }
            lifecycle::scoped_set(this->_is_being_modified, true);
            return this->_container.erase(key);
        }

        typename std::map<Key, Value>::iterator erase(typename std::map<Key, Value>::iterator position)
        {
            std::lock_guard<std::recursive_mutex> lock(this->_mutex);
            if (this->_is_being_modified)
            {
                throw cbeam::error::runtime_error("cbeam::container::thread_safe_map::erase: not allowed during modification of the map.");
            }
            lifecycle::scoped_set modifying(this->_is_being_modified, true);
            return this->_container.erase(position);
        }

        std::size_t count(const Key& key) const
        {
            std::lock_guard<std::recursive_mutex> lock(this->_mutex);
            return this->_container.count(key);
        }
 
        std::pair<typename std::map<Key, Value>::iterator, bool> insert(const Key& key, const Value& value)
        {
            std::lock_guard<std::recursive_mutex> lock(this->_mutex);
            if (this->_is_being_modified)
            {
                throw cbeam::error::runtime_error("cbeam::container::thread_safe_map::insert: not allowed during modification of the map.");
            }
            lifecycle::scoped_set modifying(this->_is_being_modified, true);
            return this->_container.insert({key, value});
        }

        std::pair<typename std::map<Key, Value>::iterator, bool> insert(const std::pair<Key, Value>& pair)
        {
            std::lock_guard<std::recursive_mutex> lock(this->_mutex);
            if (this->_is_being_modified)
            {
                throw cbeam::error::runtime_error("cbeam::container::thread_safe_map::insert: not allowed during modification of the map.");
            }
            lifecycle::scoped_set modifying(this->_is_being_modified, true);
            return this->_container.insert(pair);
        }
    };
}