Memory.h#

// Copyright (c) 2023-2025, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//

#pragma once

#include "../Defines.h"

#include <memory>
#include <type_traits>

namespace carb
{
namespace cpp
{

namespace detail
{

template <class T, class = void>
struct IsMSVCIterator : std::false_type
{
};

// OVCC-1775: MSVC iterators assert in debug if you try to take the address of them.
#if CARB_COMPILER_MSC
template <class T>
struct IsMSVCIterator<T, std::void_t<decltype(std::declval<T>()._Unwrapped())>>
    : public std::is_pointer<decltype(std::declval<T>()._Unwrapped())>
{
};
#endif

template <class T>
inline constexpr bool IsMSVCIterator_v = IsMSVCIterator<T>::value;

} // namespace detail

template <typename T>
constexpr std::enable_if_t<!std::is_array<T>::value> destroy_at(T* const p) noexcept(std::is_nothrow_destructible<T>::value)
{
    p->~T();
}

template <typename T, std::size_t N>
constexpr void destroy_at(T (*array)[N]) noexcept
{
    static_assert(noexcept(carb::cpp::destroy_at(array[0])),
                  "destroy_at for array requires elements to have noexcept destructor");

    for (T& elem : *array)
    {
        carb::cpp::destroy_at(std::addressof(elem));
    }
}

#if !CARB_HAS_CPP20 || defined DOXYGEN_BUILD

template <typename T, typename... TArgs>
T* construct_at(T* place, TArgs&&... args) noexcept
    CARB_NO_DOC((noexcept(::new (static_cast<void*>(place)) T(std::forward<TArgs>(args)...))))
{
    return ::new (static_cast<void*>(place)) T(std::forward<TArgs>(args)...);
}

template <class T>
constexpr T* to_address(T* p) noexcept
{
    static_assert(!std::is_function_v<T>, "Ill-formed if T is a function type");
    return p;
}

#    ifndef DOXYGEN_BUILD
template <class Ptr, std::enable_if_t<detail::IsMSVCIterator_v<Ptr>, bool> = false>
constexpr auto to_address(const Ptr& p) noexcept
{
    return p._Unwrapped();
}
#    endif

CARB_NO_DOC(
    template <
        class Ptr,
        std::enable_if_t<!detail::IsMSVCIterator_v<Ptr> && std::is_pointer_v<decltype(std::declval<Ptr>().operator->())>, bool> = false>
)
constexpr auto to_address(const Ptr& p) noexcept
{
    return to_address(p.operator->());
}

#else

using std::construct_at;
using std::to_address;

#endif

} // namespace cpp
} // namespace carb