thread_safe_container.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/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 <cstddef> // for std::size_t
 
#include <atomic>    // for std::atomic
#include <mutex>     // for std::recursive_mutex, std::lock_guard
#include <string>    // for std::string, std::allocator
 
namespace cbeam::container
{
    template <typename T>
    class thread_safe_container
    {
    public:
        class lock_guard
        {
            std::recursive_mutex& _mutex;
 
        public:
            explicit lock_guard(std::recursive_mutex& mutex)
                : _mutex(mutex)
            {
                _mutex.lock();
            }

            ~lock_guard() noexcept
            {
                _mutex.unlock();
            }
 
            // Deleted copy constructor and assignment operator to prevent copying.
            lock_guard(const lock_guard&)            = delete;
            lock_guard& operator=(const lock_guard&) = delete;
        };

        lock_guard get_lock_guard() const
        {
            if (_is_being_modified)
            {
                throw cbeam::error::runtime_error("cbeam::container::thread_safe_container::get_lock_guard: not allowed during destruction of the container.");
            }
            return lock_guard(_mutex);
        }

        thread_safe_container() = default;
 
        virtual ~thread_safe_container() noexcept
        {
            assert(!_is_being_modified && "cbeam::container::thread_safe_container: destruction during modification or duplicate destruction");
            _is_being_modified = true;
        }

        bool empty() const
        {
            std::lock_guard<std::recursive_mutex> lock(_mutex);
            return _container.empty();
        }

        void clear()
        {
            std::lock_guard<std::recursive_mutex> lock(_mutex);
            if (_is_being_modified)
            {
                throw cbeam::error::runtime_error("cbeam::container::thread_safe_container::clear: not allowed during modification of the container.");
            }
            lifecycle::scoped_set modifying(_is_being_modified, true);
            _container.clear();
        }

        std::size_t size() const
        {
            std::lock_guard<std::recursive_mutex> lock(_mutex);
            return _container.size();
        }

        auto begin()
        {
            std::lock_guard<std::recursive_mutex> lock(_mutex);
            return _container.begin();
        }

        auto end()
        {
            std::lock_guard<std::recursive_mutex> lock(_mutex);
            return _container.end();
        }
 
        bool is_being_modified() const
        {
            return _is_being_modified;
        }
 
    protected:
        mutable std::recursive_mutex _mutex;     
        T                            _container; 
        std::atomic<bool>            _is_being_modified{false};
    };
}