item_registry.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/overflow_error.hpp> // for cbeam::error:overflow_error
#include <cbeam/error/runtime_error.hpp>  // for cbeam::error:runtime_error
 
#include <cstddef> // for std::size_t
 
#include <mutex>     // for std::mutex, std::lock_guard
#include <set>       // for std::allocator, std::set, std::operator!=, std::_Rb_tree_const_iterator
#include <string>    // for std::operator+, std::char_traits, std::to_string
 
namespace cbeam::lifecycle
{
    class item_registry
    {
    public:
        explicit item_registry(std::size_t max_number_of_items = 0)
            : _max_number_of_items(max_number_of_items)
        {
            for (std::size_t i = 0; i < _max_number_of_items; ++i)
            {
                _available_numbers.insert(i);
            }
        }

        std::size_t register_item()
        {
            std::lock_guard<std::mutex> lock(_registry_mutex);
 
            if (_max_number_of_items > 0)
            {
                if (!_available_numbers.empty())
                {
                    auto        it          = _available_numbers.begin();
                    std::size_t item_number = *it;
                    _available_numbers.erase(it);
                    return item_number;
                }
                throw cbeam::error::overflow_error("cbeam::lifecycle::item_registry::register_item: No more item slots available. increase the maximum number of items to register more.");
            }
            else
            {
                if (!_available_numbers.empty())
                {
                    auto        it          = _available_numbers.begin();
                    std::size_t item_number = *it;
                    _available_numbers.erase(it);
                    return item_number;
                }
                if (_next_item_number == std::numeric_limits<decltype(_next_item_number)>::max())
                {
                    throw cbeam::error::overflow_error("cbeam::lifecycle::item_registry::register_item: Maximum item count reached.");
                }
                return _next_item_number++;
            }
        }

        void deregister_item(std::size_t item_number)
        {
            if (_max_number_of_items && item_number >= _max_number_of_items)
            {
                throw cbeam::error::runtime_error("cbeam::lifecycle::item_registry::deregister_item: Invalid item number " + std::to_string(item_number) + " for deregistration.");
            }
 
            std::lock_guard<std::mutex> lock(_registry_mutex);
 
            if (_available_numbers.find(item_number) != _available_numbers.end())
            {
                throw cbeam::error::runtime_error("cbeam::lifecycle::item_registry::deregister_item: Item number " + std::to_string(item_number) + " already deregistered.");
            }
 
            _available_numbers.insert(item_number);
        }
 
    private:
        const std::size_t     _max_number_of_items; 
        std::size_t           _next_item_number{0};
        std::set<std::size_t> _available_numbers; 
        std::mutex            _registry_mutex;    
    };
}