unique_alloc_deleter.hpp

/*
 * VecMem project, part of the ACTS project (R&D line)
 *
 * (c) 2021-2025 CERN for the benefit of the ACTS project
 *
 * Mozilla Public License Version 2.0
 */
 
#pragma once
 
#include <cassert>
#include <type_traits>
 
#include "vecmem/memory/memory_resource.hpp"
#include "vecmem/vecmem_core_export.hpp"
 
namespace vecmem::details {
template <typename T>
struct unique_alloc_deleter {
    /*
     * Similarly, we cannot destroy objects, so we need to ensure that
     * deallocation of objects is semantically equivalent to their destruction.
     */
    static_assert(std::is_trivially_destructible_v<std::remove_extent_t<T>>,
                  "Allocation pointer type must be trivially destructible.");
 
public:
    unique_alloc_deleter(void) = default;
 
    unique_alloc_deleter(memory_resource& mr, std::size_t s, std::size_t a = 0)
        : m_mr(&mr), m_size(s), m_align(a) {}
 
    unique_alloc_deleter(const unique_alloc_deleter& i) = default;
 
    unique_alloc_deleter(unique_alloc_deleter&& i) noexcept = default;
 
    unique_alloc_deleter& operator=(const unique_alloc_deleter& i) = default;
 
    unique_alloc_deleter& operator=(unique_alloc_deleter&& i) noexcept =
        default;
 
    void operator()(void* p) const {
        assert(m_mr != nullptr || m_size == 0u);
 
        /*
         * Non-null pointers with a zero size can happen.
         */
        if (m_size == 0u) {
            return;
        }
 
        /*
         * Deallocate the memory that we were using.
         */
        if (m_align > 0) {
            m_mr->deallocate(p, m_size, m_align);
        } else {
            m_mr->deallocate(p, m_size);
        }
    }
 
private:
    memory_resource* m_mr;
    std::size_t m_size;
    std::size_t m_align;
};
}  // namespace vecmem::details