hxallocator.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
 
HX_NS_BEGIN_

hxinline_constexpr hxsize_t hxallocator_dynamic_capacity = 0;

template<typename T_, hxsize_t fixed_capacity_>
class hxallocator {
public:
    using value_t = T_;
 
    // Template specialization below should have been selected.
    static_assert(fixed_capacity_ > hxallocator_dynamic_capacity, "Fixed capacity must be > 0");

    hxallocator(void) {
#if (HX_HARDENING_MODE) == HX_HARDENING_MODE_DEBUG
        ::memset(m_data_, 0xab, sizeof m_data_);
#endif
    }

    hxattr_nodiscard hxsize_t capacity(void) const { return fixed_capacity_; }

    const T_* data(void) const { return reinterpret_cast<const T_*>(m_data_); }

    T_* data(void) { return reinterpret_cast<T_*>(m_data_); }

    void reserve_storage(hxsize_t size_,
            hxsystem_allocator_t allocator_=hxsystem_allocator_current,
            hxalignment_t alignment_=hxalignment) {
        (void)allocator_; (void)alignment_;
        hxassert_always(size_ == fixed_capacity_, "reallocation_disallowed");
    }
 
private:
    hxallocator(const hxallocator&) = delete;
    void operator=(const hxallocator&) = delete;
 
    alignas(T_) char m_data_[fixed_capacity_ * hxsizeof<T_>()];
};

template<typename T_>
class hxallocator<T_, hxallocator_dynamic_capacity> {
public:
    using value_t = T_;

    hxallocator(void) {
        m_data_ = hxnull;
        m_capacity_ = 0;
    }

    ~hxallocator(void) {
        if(m_data_) {
            m_capacity_ = 0;
            hxfree(m_data_);
            m_data_ = hxnull;
        }
    }

    hxattr_nodiscard hxsize_t capacity(void) const { return m_capacity_; }

    const T_* data(void) const { return m_data_; }

    T_* data(void) { return m_data_; }

    void reserve_storage(hxsize_t size_,
            hxsystem_allocator_t allocator_=hxsystem_allocator_current,
            hxalignment_t alignment_=hxalignment) {
        if(size_ == m_capacity_) {
            return;
        }
        hxassert_always(m_capacity_ == 0, "reallocation_disallowed");
        m_data_ = static_cast<T_*>(hxmalloc_ext(sizeof(T_) * static_cast<size_t>(size_), allocator_, alignment_));
        m_capacity_ = size_;
    }
 
private:
    hxallocator(const hxallocator&) = delete;
    void operator=(const hxallocator&) = delete;
 
    hxsize_t m_capacity_;
    T_* m_data_;
};
 
HX_NS_END_