hxhandle_table.hpp

Go to the documentation of this file.

#pragma once
// SPDX-FileCopyrightText: © 2017-2026 Adrian Johnston.
// SPDX-License-Identifier: MIT
// This file is licensed under the MIT license found in the LICENSE.md file.

 
#include "libhatchet.h"
 
// HX_USE_MACROS_WITH_MODULE allows including macros alongside the module.
#if HX_USE_MACROS_WITH_MODULE
#error Header does not provide macros alone.
#endif
 
#include "hxptr.hpp"
#include "hxallocator.hpp"
 
HX_NS_BEGIN_
 
#include "detail/hxpow2_allocator.hpp"

template<typename T_,
    typename deleter_t_=hxdefault_delete,
    uint32_t table_size_bits_=hxallocator_dynamic_capacity>
class hxhandle_table : private deleter_t_ {
public:
    // The capacity and a guard bit must fit in 32-bits to avoid 64-bit emulation.
    static_assert(table_size_bits_ <= 30u, "hxhandle_table is designed for 2^30 or less slots");
 
    using value_t = T_;

    explicit hxhandle_table(deleter_t_ deleter_=deleter_t_());

    ~hxhandle_table(void);

    hxattr_nodiscard hxsize_t capacity(void) const { return static_cast<hxsize_t>(m_table_.get_mask_()); }

    template<typename deleter_u_>
    void clear(deleter_u_&& deleter_) noexcept;

    void clear(void) noexcept { this->clear(this->deleter()); }

    hxattr_nodiscard bool empty(void) const { return m_size_ == 0; }

    template<typename deleter_u_>
    bool erase(hxhandle_t handle_, deleter_u_&& deleter_) noexcept;

    bool erase(hxhandle_t handle_) noexcept { return this->erase(handle_, this->deleter()); }

    template<typename callable_t_>
    hxsize_t erase_if(callable_t_&& callable_) noexcept;

    hxptr<T_, deleter_t_> extract(hxhandle_t handle_) noexcept;

    hxattr_nodiscard hxinline hxattr_flatten bool full(void) const { return m_free_head_ == m_table_.data(); }

    hxattr_nodiscard T_* get(hxhandle_t handle_) noexcept;

    hxattr_nodiscard const T_* get(hxhandle_t handle_) const noexcept;

    hxattr_nodiscard const deleter_t_& deleter(void) const;

    hxattr_nodiscard deleter_t_& deleter(void);

    hxhandle_t insert(T_* ptr_) noexcept;

    template<typename deleter_u_>
    hxhandle_t insert(hxptr<T_, deleter_u_>&& ptr_) noexcept;

    hxattr_nodiscard hxinline hxattr_flatten hxsize_t max_size(void) const { return static_cast<hxsize_t>(m_table_.get_mask_()); }

    void release_all(void) noexcept { this->clear(hxdo_not_delete()); }

    void set_size_bits(uint32_t bits_);

    hxattr_nodiscard hxsize_t size(void) const { return static_cast<hxsize_t>(m_size_); }
 
private:
    class slot_t_ {
    public:
        uint64_t m_key_;
        union {
            T_* m_ptr_;
            slot_t_* m_next_;
        };
    };
 
    void build_free_list_(void);
 
    hxdetail_::hxpow2_allocator_<slot_t_, table_size_bits_, false> m_table_;
    uint32_t m_size_;
    slot_t_* m_free_head_;
};
 
#include "detail/hxhandle_table.inl"
HX_NS_END_