unique_obj_deleter.hpp

/*
 * VecMem project, part of the ACTS project (R&D line)
 *
 * (c) 2021-2023 CERN for the benefit of the ACTS project
 *
 * Mozilla Public License Version 2.0
 */
 
#pragma once
 
// Local include(s).
#include "vecmem/memory/memory_resource.hpp"
 
// System include(s).
#include <cassert>
#include <type_traits>
 
namespace vecmem::details {
template <typename T>
struct unique_obj_deleter {
public:
    static_assert(!std::is_array_v<T> ||
                      (std::is_array_v<T> && std::extent_v<T> == 0),
                  "Pointer type of unique object must be either non-array or "
                  "unbound array type.");
 
    using pointer_t =
        std::conditional_t<std::is_array_v<T>, std::decay_t<T>, T*>;
    using storage_t = std::remove_pointer_t<pointer_t>;
 
    unique_obj_deleter(void) = default;
 
    unique_obj_deleter(memory_resource& mr, std::size_t s, std::size_t a = 0,
                       std::size_t n = 1)
        : m_mr(&mr), m_size(s), m_align(a), m_elems(n) {}
 
    unique_obj_deleter(const unique_obj_deleter& i) = default;
 
    unique_obj_deleter(unique_obj_deleter&& i) = default;
 
    unique_obj_deleter& operator=(const unique_obj_deleter& i) = default;
 
    unique_obj_deleter& operator=(unique_obj_deleter&& i) = default;
 
    void operator()(pointer_t p) const {
        assert(m_mr != nullptr || m_size == 0u);
 
        /*
         * Non-null pointers with a zero size can happen.
         */
        if (m_size == 0u) {
            return;
        }
 
        /*
         * The class exhibits different behaviour for array types and non-array
         * types.
         */
        if constexpr (!std::is_array_v<T>) {
            /*
             * If we are deleting a non-array type, we can simply call the
             * stored object's destructor.
             */
            p->~T();
        } else if constexpr (std::is_array_v<T>) {
            /*
             * If we are deleting an array type instead, we need to iterate
             * over each of our stored elements and destruct them.
             */
            for (std::size_t i = 0; i < m_elems; ++i) {
                p[i].~storage_t();
            }
        }
 
        /*
         * Finally, we need to deallocate the memory. For this, we use the
         * memory resource, and we optionally pass it an alignment value.
         */
        if (m_align > 0) {
            m_mr->deallocate(p, m_size, m_align);
        } else {
            m_mr->deallocate(p, m_size);
        }
    };
 
private:
    /*
     * This should really be a reference, but using a reference here makes the
     * class non-default destructible. At least - without some messy use of
     * default memory resources. Using a pointer here is not ideal, but it
     * allows us to make use of empty unique pointers.
     */
    memory_resource* m_mr;
    std::size_t m_size;
    std::size_t m_align;
    std::size_t m_elems;
};
}  // namespace vecmem::details