hxfree_list.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_
 
#if HX_CPLUSPLUS >= 202002L

template<typename T_>
concept hxfree_list_concept_ = requires(T_& x_) {
    sizeof(T_);
    { x_.~T_() };
};
#else
#define hxfree_list_concept_ typename
#endif

template<hxfree_list_concept_ T_, hxsize_t capacity_=hxallocator_dynamic_capacity>
class hxfree_list : private hxallocator<T_, capacity_> {
public:
    class deleter_t {
    public:
        explicit deleter_t(hxfree_list& owner_) noexcept : m_owner_(&owner_) { }

        void operator()(T_* p_) noexcept { if(p_ != hxnull) { m_owner_->release(p_); } }

        operator bool(void) const { return true; }
 
    private:
        hxfree_list* m_owner_;
    };

    using value_t = T_;

    using ptr_t = hxptr<T_, deleter_t>;

    explicit hxfree_list(void) noexcept;

    hxfree_list(hxfree_list&& x_) noexcept;

    ~hxfree_list(void) noexcept;

    template<typename... args_t_>
    hxattr_nodiscard hxptr<T_, deleter_t> allocate(args_t_&&... args_) noexcept;

    hxattr_nodiscard hxsize_t capacity(void) const;

    deleter_t deleter(void) noexcept { return deleter_t(*this); }

    hxattr_nodiscard bool empty(void) const { return m_free_head_ == hxnull; }

    hxattr_nodiscard bool is_allocator(const T_* p_) const noexcept;

    template<typename deleter_t_>
    hxattr_nodiscard bool is_allocator(const hxptr<T_, deleter_t_>& ptr_) const noexcept;

    hxattr_nodiscard hxsize_t max_size(void) const { return this->capacity(); }

    void release(T_* p_) noexcept hxattr_nonnull(2);

    template<typename deleter_t_>
    void release(hxptr<T_, deleter_t_>&& ptr_) noexcept;

    void reserve(hxsize_t size_,
            hxsystem_allocator_t allocator_=hxsystem_allocator_current,
            hxalignment_t alignment_=hxalignment) noexcept;

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

    template<typename... args_t_>
    hxattr_nodiscard hxptr<T_, deleter_t> try_allocate(args_t_&&... args_) noexcept;
 
private:
    hxfree_list(const hxfree_list&) = delete;
    void operator=(const hxfree_list&) = delete;
 
    union slot_ {
        slot_* next_;
        T_ value_;
        slot_(void) { }
        ~slot_(void) { }
    };
 
    void enqueue_all_(hxsize_t count_) noexcept;
 
    slot_* m_free_head_;
    hxsize_t m_size_;
};
 
#include "detail/hxfree_list.inl"
HX_NS_END_