UT_UniquePtr.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_UniquePtr.h (UT Library, C++)
 *
 * COMMENTS:    
 * 
 * RELATION TO THE STL:
 *
 *     Use UT_UniquePtr instead of std::unique_ptr for a consistent style.
 *     It has special traits defined that make it easily usable in UT_ArraySet
 *     and UT_ArrayMap.
 *
 */

#ifndef __UT_UNIQUEPTR_H_INCLUDED__
#define __UT_UNIQUEPTR_H_INCLUDED__

#include <stddef.h>
#include <memory> // IWYU pragma: export
#include <type_traits>
#include <utility>

/// @file

/// @brief A smart pointer for unique ownership of dynamically allocated objects
///
/// UT_UniquePtr mimics a built-in pointer except that it guarantees deletion
/// of the object pointed to, either upon destruction or via an explicit
/// reset(). UT_UniquePtr is a simple solution for simple needs; use
/// UT_SharedPtr/UT_IntrusivePtr if your needs are more complex.
///
template<
    class T,
    class Deleter = std::default_delete<T>
>
using UT_UniquePtr = std::unique_ptr<T, Deleter>;


/// Constructs an object of type T and wraps it in an UT_UniquePtr. The args
/// are passed to the constructor of T.
template<
    class T,
    class... REST,
    std::enable_if_t<!std::is_array_v<T>, int> = 0
>
inline UT_UniquePtr<T>
UTmakeUnique(REST&&... args)
{
    return UT_UniquePtr<T>(new T(std::forward<REST>(args)...));
}

/// Construct a value initialized 1D array of type T with len elements 
template<
    class T,
    std::enable_if_t<std::is_array_v<T> && std::extent_v<T> == 0, int> = 0
>
inline UT_UniquePtr<T>
UTmakeUnique(size_t len)
{
    using ElemT = std::remove_extent_t<T>;
    return UT_UniquePtr<T>(new ElemT[len]());
}

/// Construction of arrays of known bound is disallowed. Just do it directly!
template<
    class T,
    class... REST,
    std::enable_if_t<std::extent_v<T> != 0, int> = 0
>
void UTmakeUnique(REST&&...) = delete;

/// Construct a default initialized T in a UT_UniquePtr
template <
    class T,
    std::enable_if_t<!std::is_array_v<T>, int> = 0
>
inline UT_UniquePtr<T>
UTmakeUniqueForOverwrite()
{
    return UT_UniquePtr<T>(new T);
}

/// Construct a default initialized 1D array of type T with len elements 
template <
    class T,
    std::enable_if_t<std::is_array_v<T> && std::extent_v<T> == 0, int> = 0
>
inline UT_UniquePtr<T>
UTmakeUniqueForOverwrite(size_t len)
{
    using ElemT = std::remove_extent_t<T>;
    return UT_UniquePtr<T>(new ElemT[len]);
}

/// Construction of arrays of known bound is disallowed. Just do it directly!
template <
    class T,
    class... REST,
    std::enable_if_t<std::extent_v<T> != 0, int> = 0
>
void UTmakeUniqueForOverwrite(REST&&...) = delete;

/// Unary equality predicate for UT_Array removeIf()/findIf() methods
template <typename T>
class UT_UniquePtrIsEqual
{
public:
    UT_UniquePtrIsEqual(const T *ptr)
        : myPtr(ptr)
    {
    }

    bool operator()(const UT_UniquePtr<T> &elem)
    {
        return myPtr == elem.get();
    }

private:
    const T *myPtr;
};

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

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

#endif // __UT_UNIQUEPTR_H_INCLUDED__