unique_ptr.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 <algorithm>
#include <cstddef>
#include <memory>
#include <new>
#include <type_traits>
 
#include "vecmem/memory/details/unique_alloc_deleter.hpp"
#include "vecmem/memory/details/unique_obj_deleter.hpp"
#include "vecmem/memory/memory_resource.hpp"
#include "vecmem/vecmem_core_export.hpp"
 
namespace vecmem {
namespace details {
 
template <typename T>
T get_nonexistent_pointer() {
    return reinterpret_cast<T>(0xf000U);
}
 
}  // namespace details
 
template <typename T>
using unique_obj_ptr = std::unique_ptr<T, details::unique_obj_deleter<T>>;
 
template <typename T>
using unique_alloc_ptr = std::unique_ptr<T, details::unique_alloc_deleter<T>>;
 
template <typename T, typename... Args>
typename std::enable_if_t<!std::is_array_v<T>, unique_obj_ptr<T>>
make_unique_obj(memory_resource& m, std::align_val_t alignment, Args&&... a) {
    /*
     * Calculate the size of the allocation and use the memory resource to
     * perform an allocation of the requested size.
     */
    std::size_t s = sizeof(T);
    std::size_t align =
        std::max(static_cast<std::size_t>(alignment), alignof(T));
    T* p = static_cast<T*>(m.allocate(s, align));
 
    /*
     * Perform a placement-new with forwarded arguments to construct the
     * object.
     */
    new (p) T(std::forward<Args>(a)...);
 
    /*
     * Create a new unique_ptr, with its own deleter, and return it.
     */
    return unique_obj_ptr<T>(p, details::unique_obj_deleter<T>(m, s, align));
}
 
template <typename T, typename... Args>
typename std::enable_if_t<!std::is_array_v<T>, unique_obj_ptr<T>>
make_unique_obj(memory_resource& m, Args&&... a) {
    return make_unique_obj<T>(m, std::align_val_t{alignof(T)},
                              std::forward<Args>(a)...);
}
 
template <typename T>
typename std::enable_if_t<std::is_array_v<T> && std::extent_v<T> == 0,
                          unique_obj_ptr<T>>
make_unique_obj(memory_resource& m, std::size_t n, std::align_val_t alignment) {
    using pointer_t = typename unique_obj_ptr<T>::deleter_type::pointer_t;
 
    // Handle the case with zero elements.
    if (n == 0) {
        return unique_obj_ptr<T>(details::get_nonexistent_pointer<pointer_t>());
    }
 
    /*
     * Calculate the size of the allocation and use the memory resource to
     * perform an allocation of the requested size.
     */
    std::size_t s = n * sizeof(std::remove_extent_t<T>);
    std::size_t align = std::max(static_cast<std::size_t>(alignment),
                                 alignof(std::remove_extent_t<T>));
    pointer_t p = static_cast<pointer_t>(m.allocate(s, align));
 
    /*
     * Use placement-new to default-construct each of our elements.
     */
    for (std::size_t i = 0; i < n; ++i) {
        new (&p[i]) std::remove_extent_t<T>();
    }
 
    /*
     * Create a new unique_ptr, with its own deleter, and return it.
     */
    return unique_obj_ptr<T>(p, details::unique_obj_deleter<T>(m, s, align, n));
}
 
template <typename T>
typename std::enable_if_t<std::is_array_v<T> && std::extent_v<T> == 0,
                          unique_obj_ptr<T>>
make_unique_obj(memory_resource& m, std::size_t n) {
    return make_unique_obj<T>(
        m, n, std::align_val_t{alignof(std::remove_extent_t<T>)});
}
 
template <typename T>
unique_alloc_ptr<T> make_unique_alloc(memory_resource& m,
                                      std::align_val_t alignment) {
    /*
     * This method only works on non-array types and bounded array types.
     */
    static_assert(!(std::is_array_v<T> && std::extent_v<T> == 0),
                  "Allocation pointer type cannot be an unbounded array.");
 
    /*
     * Since we cannot (in general) construct objects in the memory we are
     * about to allocate, we need to make sure that "bare", unallocated memory
     * is semantically compatible with construction of the requested type.
     */
    static_assert(std::is_trivially_constructible_v<std::remove_extent_t<T>>,
                  "Allocation pointer type must be trivially constructible.");
 
    using pointer_t =
        std::conditional_t<std::is_array_v<T>, std::decay_t<T>, T*>;
 
    /*
     * Calculate the size of the allocation and use the memory resource to
     * perform an allocation of the requested size.
     */
    std::size_t s = sizeof(T);
    std::size_t align = std::max(static_cast<std::size_t>(alignment),
                                 alignof(std::remove_extent_t<T>));
    pointer_t p = static_cast<pointer_t>(m.allocate(s, align));
 
    /*
     * Create a new unique_ptr, with its own deleter, and return it.
     */
    return unique_alloc_ptr<T>(p,
                               details::unique_alloc_deleter<T>(m, s, align));
}
 
template <typename T>
unique_alloc_ptr<T> make_unique_alloc(memory_resource& m) {
    return make_unique_alloc<T>(
        m, std::align_val_t{alignof(std::remove_extent_t<T>)});
}
 
template <typename T>
unique_alloc_ptr<T> make_unique_alloc(memory_resource& m, std::size_t n,
                                      std::align_val_t alignment) {
    /*
     * This overload only works for unbounded array types.
     */
    static_assert(std::is_array_v<T>,
                  "Allocation pointer type must be an array type.");
    static_assert(std::extent_v<T> == 0,
                  "Allocation pointer type must be unbounded.");
 
    /*
     * Since we cannot (in general) construct objects in the memory we are
     * about to allocate, we need to make sure that "bare", unallocated memory
     * is semantically compatible with construction of the requested type.
     */
    static_assert(std::is_trivially_constructible_v<std::remove_extent_t<T>>,
                  "Allocation pointer type must be trivially constructible.");
 
    using pointer_t =
        std::conditional_t<std::is_array_v<T>, std::decay_t<T>, T*>;
 
    // Handle the case with zero elements.
    if (n == 0) {
        return unique_alloc_ptr<T>(
            details::get_nonexistent_pointer<pointer_t>());
    }
 
    /*
     * Calculate the size of the allocation and use the memory resource to
     * perform an allocation of the requested size.
     */
    std::size_t s = n * sizeof(std::remove_extent_t<T>);
    std::size_t align = std::max(static_cast<std::size_t>(alignment),
                                 alignof(std::remove_extent_t<T>));
    pointer_t p = static_cast<pointer_t>(m.allocate(s, align));
 
    /*
     * Create a new unique_ptr, with its own deleter, and return it.
     */
    return unique_alloc_ptr<T>(p,
                               details::unique_alloc_deleter<T>(m, s, align));
}
 
template <typename T>
unique_alloc_ptr<T> make_unique_alloc(memory_resource& m, std::size_t n) {
    return make_unique_alloc<T>(
        m, n, std::align_val_t{alignof(std::remove_extent_t<T>)});
}
 
template <typename T, typename C>
typename std::enable_if_t<!(std::is_array_v<T> && std::extent_v<T> == 0),
                          unique_alloc_ptr<T>>
make_unique_alloc(memory_resource& m, const T* f, const C& c) {
    /*
     * This method only works on non-array types and bounded array types. This
     * is enforced through SFINAE, so that a call with an unbounded array type,
     * a count of 0 and an alignment is not ambiguous with this overload.
     */
 
    /*
     * In this case, we are going to immediately copy some (hopefully) live
     * objects into our new allocation, so trivial constructability is not a
     * hard requirement. Rather, we must ensure that a memory copy is a valid
     * way of constructing types, which we do by checking trivial copyability.
     */
    static_assert(std::is_trivially_copyable_v<std::remove_extent_t<T>>,
                  "Allocation pointer type must be trivially copyable.");
 
    using pointer_t =
        std::conditional_t<std::is_array_v<T>, std::decay_t<T>, T*>;
 
    /*
     * Calculate the size of the allocation and use the memory resource to
     * perform an allocation of the requested size.
     */
    std::size_t s = sizeof(T);
    std::size_t align = alignof(std::remove_extent_t<T>);
    pointer_t p = static_cast<pointer_t>(m.allocate(s, align));
 
    c(p, f, s);
 
    /*
     * Create a new unique_ptr, with its own deleter, and return it.
     */
    return unique_alloc_ptr<T>(p,
                               details::unique_alloc_deleter<T>(m, s, align));
}
 
template <typename T, typename C>
unique_alloc_ptr<T> make_unique_alloc(memory_resource& m, std::size_t n,
                                      const std::remove_extent_t<T>* f,
                                      const C& c) {
    /*
     * This overload only works for unbounded array types.
     */
    static_assert(std::is_array_v<T>,
                  "Allocation pointer type must be an array type.");
    static_assert(std::extent_v<T> == 0,
                  "Allocation pointer type must be unbounded.");
 
    /*
     * In this case, we are going to immediately copy some (hopefully) live
     * objects into our new allocation, so trivial constructability is not a
     * hard requirement. Rather, we must ensure that a memory copy is a valid
     * way of constructing types, which we do by checking trivial copyability.
     */
    static_assert(std::is_trivially_copyable_v<std::remove_extent_t<T>>,
                  "Allocation pointer type must be trivially copyable.");
 
    using pointer_t =
        std::conditional_t<std::is_array_v<T>, std::decay_t<T>, T*>;
 
    // Handle the case with zero elements.
    if (n == 0) {
        return unique_alloc_ptr<T>(
            details::get_nonexistent_pointer<pointer_t>());
    }
 
    /*
     * Calculate the size of the allocation and use the memory resource to
     * perform an allocation of the requested size.
     */
    std::size_t s = n * sizeof(std::remove_extent_t<T>);
    std::size_t align = alignof(std::remove_extent_t<T>);
    pointer_t p = static_cast<pointer_t>(m.allocate(s, align));
 
    c(p, f, s);
 
    /*
     * Create a new unique_ptr, with its own deleter, and return it.
     */
    return unique_alloc_ptr<T>(p,
                               details::unique_alloc_deleter<T>(m, s, align));
}
}  // namespace vecmem