UT_SharedPtr.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_SharedPtr.h (UT Library, C++)
 *
 * COMMENTS:    
 *
 * RELATION TO THE STL:
 *
 *     Use UT_SharedPtr instead of std::shared_ptr for a consistent style.
 *     It has special traits defined that make it easily usable in UT_ArraySet
 *     and UT_ArrayMap.
 *
 */

#ifndef __UT_SHAREDPTR_H_INCLUDED__
#define __UT_SHAREDPTR_H_INCLUDED__

#include <memory>
#include <type_traits>
#include <utility>
#include <stddef.h>

/// @brief Wrapper around std::shared_ptr
///
/// An shared pointer takes ownership of the object referenced.  The reference
/// counting is done outside the object interface, so the size of a
/// UT_SharedPtr is larger than a vanilla pointer.
///
/// As this is a wrapper around the boost shared pointer template, the type (T)
/// must have a <b>Copy Constructor</b> and a valid <b>Assignment Operator</b>
/// @see UT_IntrusivePtr
template <typename T>
using UT_SharedPtr = std::shared_ptr<T>;

template <typename T>
using UTenable_shared_from_this = std::enable_shared_from_this<T>;

#define UTallocateShared std::allocate_shared

#define UTstatic_pointer_cast       std::static_pointer_cast
#define UTdynamic_pointer_cast      std::dynamic_pointer_cast
#define UTconst_pointer_cast        std::const_pointer_cast
#define UTreinterpret_pointer_cast  std::reinterpret_pointer_cast

template <typename T>
using UT_WeakPtr = std::weak_ptr<T>;

/// Return a UT_SharedPtr<T> that points to an array of T[len] buffer.
/// Only needed until we have proper support in C++20.
/// TODO: Bring back r389476 when macOS has __cpp_lib_shared_ptr_arrays
///       implemented.
template <typename T>
inline UT_SharedPtr<T>
UTmakeSharedArrayPtr(size_t len)
{
    return UT_SharedPtr<T>(new T[len], [](T* p) { delete [] p; });
}

// is_(un)bounded_array here only until C++20 arrives
namespace UT {
namespace detail {
    template<class T>
    struct is_unbounded_array : std::false_type {};
    template<class T>
    struct is_unbounded_array<T[]> : std::true_type {};

    template<class T>
    struct is_bounded_array : std::false_type {};
    template<class T, std::size_t N>
    struct is_bounded_array<T[N]> : std::true_type {};
}}

/// Create UT_SharedPtr<T> to T constructed with args
template <typename T, typename... Args>
inline std::enable_if_t<
    !std::is_array<T>::value,
    UT_SharedPtr<T>
>
UTmakeShared(Args&&... args)
{
    return std::make_shared<T>(std::forward<Args>(args)...);
}

/// Create UT_SharedPtr<T[]> that points to an array of T[len] buffer
/// @warning This is currently disabled until C++20
template <typename T>
inline std::enable_if_t<
    UT::detail::is_unbounded_array<T>::value,
    UT_SharedPtr<T>
>
UTmakeShared(size_t len)
{
    // This cannot be enabled until all supported compilers have
    // __cpp_lib_shared_ptr_arrays defined
#if 0
    return std::make_shared<T>(len);
#else
    static_assert(sizeof(std::remove_extent_t<T>) == 0,
        "Not allowed until C++20, use UTmakeSharedArrayPtr<T>() instead");
#endif
}

/// Create UT_SharedPtr<T[N]> that points to a T[N] fixed array
/// @warning This is currently disabled until C++20
template <typename T>
inline std::enable_if_t<
    UT::detail::is_bounded_array<T>::value,
    UT_SharedPtr<T>
>
UTmakeShared()
{
    // This cannot be enabled until all supported compilers have
    // __cpp_lib_shared_ptr_arrays defined
#if 0
    return std::make_shared<T>();
#else
    static_assert(sizeof(std::remove_extent_t<T>) == 0,
        "Not allowed until C++20, use UTmakeSharedArrayPtr<T>() instead");
#endif
}


// For UT::ArraySet.
namespace UT
{
template <typename T>
struct DefaultClearer;

template <typename T>
struct DefaultClearer<UT_SharedPtr<T>>
{
    static void clear(UT_SharedPtr<T> &v) { v = UT_SharedPtr<T>(); }
    static bool isClear(const UT_SharedPtr<T> &v) { return v.get() == nullptr; }
    static void clearConstruct(UT_SharedPtr<T> *p)
    {
        new ((void *)p) UT_SharedPtr<T>(nullptr);
    }
    static const bool clearNeedsDestruction = false;
};
} // namespace UT

#endif // __UT_SHAREDPTR_H_INCLUDED__