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 "hxallocator.hpp"
#include "hxptr.hpp"
 
HX_NS_BEGIN_
 
#include "detail/hxpow2_allocator.hpp"
 
#if HX_CPLUSPLUS >= 202002L
template<typename T_>
concept hxhandle_table_concept_ = requires(T_& x_) {
    sizeof(T_);
    x_.~T_();
};
#else
#define hxhandle_table_concept_ typename
#endif

template<hxhandle_table_concept_ 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);
 
#if HX_CPLUSPLUS >= 202302L
    template<typename self_t_, typename callable_t_>
    hxattr_nodiscard auto and_then(
        this self_t_&& self_, hxhandle_t handle_, callable_t_&& callable_)
        -> hxremove_cvref_t<decltype(
            hxforward<callable_t_>(callable_)(
                hxforward_like<self_t_>(hxdeclval<T_&>())))>;
#endif // HX_CPLUSPLUS >= 202302L

    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 const deleter_t_& deleter(void) const;
 
    hxattr_nodiscard deleter_t_& deleter(void);

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

    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();
    }

    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_());
    }
 
#if HX_CPLUSPLUS >= 202302L
    template<typename self_t_, typename callable_t_>
    hxattr_nodiscard auto or_else(
        this self_t_&& self_, hxhandle_t handle_, callable_t_&& callable_)
        -> decltype(self_.value(handle_));
#endif // HX_CPLUSPLUS >= 202302L

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

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

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

    void set_size_bits(uint32_t bits_);

    hxattr_nodiscard hxsize_t size(void) const { return static_cast<hxsize_t>(m_size_); }

    hxattr_nodiscard const T_* value(hxhandle_t handle_) const noexcept;
 
    hxattr_nodiscard T_* value(hxhandle_t handle_) noexcept;
 
#if HX_CPLUSPLUS >= 202302L
    template<typename self_t_, typename... args_t_>
    hxattr_nodiscard T_ value_or(
        this self_t_&& self_, hxhandle_t handle_, args_t_&&... args_);
#endif // HX_CPLUSPLUS >= 202302L
 
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_