object_pool.h

Go to the documentation of this file.

// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025  Medusa Slockbower
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program 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 General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
 
 
#ifndef FENNEC_CONTAINERS_OBJECT_POOL_H
#define FENNEC_CONTAINERS_OBJECT_POOL_H
 
#include <fennec/containers/dynarray.h>
#include <fennec/containers/list.h>
#include <fennec/containers/optional.h>
 
namespace fennec
{
 
template<typename TypeT, typename AllocT = allocator<TypeT>>
struct object_pool {
 
// Definitions =========================================================================================================
public:
    using value_t = TypeT;
    using elem_t  = optional<value_t>;
    using table_t = dynarray<elem_t, AllocT>;
    using freed_t = list<size_t, AllocT>;
 
    class iterator;
    class const_iterator;
 
 
// Constructors & Destructor ===========================================================================================
 
 
    constexpr object_pool()
        : _size(0) {
    }
 
    constexpr ~object_pool() = default;
 
 
 
// Properties ==========================================================================================================
 
 
    constexpr size_t size() const {
        return _size;
    }
 
    constexpr size_t capacity() const {
        return _table.capacity();
    }
 
    constexpr bool empty() const {
        return size() == 0;
    }
 
    constexpr size_t next_id() const {
        size_t next = _size;
        if (not _freed.empty()) {
            next = _freed.front();
        }
        return next;
    }
 
 
// Access ==============================================================================================================
 
 
    constexpr value_t& operator[](size_t i) {
        assert(i < capacity(), "Index out of Bounds!");
        assert(_table[i], "Attempted to access null object.")
        return *_table[i];
    }
 
    constexpr const value_t& operator[](size_t i) const {
        assert(i < capacity(), "Index out of Bounds!");
        assert(_table[i], "Attempted to access null object.")
        return *_table[i];
    }
 
 
 
// Modifiers ===========================================================================================================
 
 
    constexpr size_t insert(value_t&& x) {
        return this->_insert(fennec::forward<value_t>(x));
    }
 
    constexpr size_t insert(const value_t& x) {
        return this->_insert(x);
    }
 
 
    template<typename...ArgsT>
    constexpr size_t emplace(ArgsT&&...args) {
        return this->_insert(fennec::forward<ArgsT>(args)...);
    }
 
    constexpr void erase(size_t i) {
        _table[i] = nullopt;
        _freed.push_back(i);
        --_size;
    }
 
    constexpr void clear() {
        for (auto& it : _table) {
            it = nullopt;
        }
        _size = 0;
        _freed.clear();
    }
 
 
 
// Iterator ============================================================================================================
 
    iterator begin() {
        return iterator(this, 0);
    }
 
    iterator end() {
        return iterator(this, _size);
    }
 
    const_iterator begin() const {
        return iterator(this, 0);
    }
 
    const_iterator end() const {
        return iterator(this, _size);
    }
 
    class iterator {
    public:
        iterator(object_pool* pool, size_t start)
            : pool(pool), curr(start) {
            _fix();
        }
 
        iterator(const iterator&)     = default;
        iterator(iterator&&) noexcept = default;
 
        ~iterator() = default;
 
        iterator& operator=(const iterator&)     = default;
        iterator& operator=(iterator&&) noexcept = default;
 
        iterator operator++(int) {
            iterator ret = *this;
            ++curr;
            _fix();
            return ret;
        }
 
        iterator& operator++() {
            ++curr;
            _fix();
            return *this;
        }
 
        value_t& operator*() const {
            return *pool->_table[curr];
        }
 
        value_t* operator->() const {
            return *pool->_table[curr];
        }
 
        bool operator==(const iterator& it) {
            return pool == it.pool and curr == it.curr;
        }
 
        bool operator!=(const iterator& it) {
            return pool != it.pool or curr != it.curr;
        }
 
    private:
        object_pool* pool;
        size_t       curr;
 
        void _fix() {
            while (curr < pool->_size and not pool->_table[curr]) {
                ++curr;
            }
        }
    };
 
    class const_iterator {
    public:
        const_iterator(const object_pool* pool, size_t start)
            : pool(pool), curr(start) {
            _fix();
        }
 
        const_iterator(const const_iterator&)     = default;
        const_iterator(const_iterator&&) noexcept = default;
 
        ~const_iterator() = default;
 
        const_iterator& operator=(const const_iterator&)     = default;
        const_iterator& operator=(const_iterator&&) noexcept = default;
 
        const_iterator operator++(int) {
            const_iterator ret = *this;
            ++curr;
            _fix();
            return ret;
        }
 
        const_iterator& operator++() {
            ++curr;
            _fix();
            return *this;
        }
 
        const value_t& operator*() const {
            return *pool->_table[curr];
        }
 
        const value_t* operator->() const {
            return *pool->_table[curr];
        }
 
        bool operator==(const const_iterator& it) {
            return pool == it.pool and curr == it.curr;
        }
 
        bool operator!=(const const_iterator& it) {
            return pool != it.pool or curr != it.curr;
        }
 
    private:
        const object_pool* pool;
        size_t             curr;
 
        void _fix() {
            while (curr < pool->_size and not pool->_table[curr]) {
                ++curr;
            }
        }
    };
 
private:
    table_t _table;
    freed_t _freed;
    size_t  _size;
 
    size_t _next_free() {
        size_t next = _size;
        if (not _freed.empty()) {
            next = _freed.front();
            _freed.pop_front();
        }
        ++_size;
        return next;
    }
 
    template<typename...ArgsT>
    size_t _insert(ArgsT&&...args) {
        size_t i = _next_free();
        if (i >= _table.size()) {
            _table.resize(fennec::max(_table.size() * 2, size_t(8)));
        }
        _table[i].emplace(fennec::forward<ArgsT>(args)...);
        return i;
    }
};
 
}
 
#endif // FENNEC_CONTAINERS_OBJECT_POOL_H