HELLO·Android
系统源代码
IT资讯
技术文章
我的收藏
注册
登录
-
我收藏的文章
创建代码块
我的代码块
我的账号
Pie
|
9.0.0_r8
下载
查看原文件
收藏
根目录
prebuilts
clang
host
linux-x86
clang-4479392
include
llvm
ADT
STLExtras.h
//===- llvm/ADT/STLExtras.h - Useful STL related functions ------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file contains some templates that are useful if you are working with the // STL at all. // // No library is required when using these functions. // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_STLEXTRAS_H #define LLVM_ADT_STLEXTRAS_H #include
// for std::all_of #include
#include
// for std::size_t #include
// for qsort #include
#include
#include
#include
#include
#include
// for std::pair #include "llvm/ADT/Optional.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/iterator.h" #include "llvm/ADT/iterator_range.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ErrorHandling.h" namespace llvm { // Only used by compiler if both template types are the same. Useful when // using SFINAE to test for the existence of member functions. template
struct SameType; namespace detail { template
using IterOfRange = decltype(std::begin(std::declval
())); template
using ValueOfRange = typename std::remove_reference
()))>::type; } // End detail namespace //===----------------------------------------------------------------------===// // Extra additions to
//===----------------------------------------------------------------------===// template
struct identity : public std::unary_function
{ Ty &operator()(Ty &self) const { return self; } const Ty &operator()(const Ty &self) const { return self; } }; template
struct less_ptr : public std::binary_function
{ bool operator()(const Ty* left, const Ty* right) const { return *left < *right; } }; template
struct greater_ptr : public std::binary_function
{ bool operator()(const Ty* left, const Ty* right) const { return *right < *left; } }; /// An efficient, type-erasing, non-owning reference to a callable. This is /// intended for use as the type of a function parameter that is not used /// after the function in question returns. /// /// This class does not own the callable, so it is not in general safe to store /// a function_ref. template
class function_ref; template
class function_ref
{ Ret (*callback)(intptr_t callable, Params ...params); intptr_t callable; template
static Ret callback_fn(intptr_t callable, Params ...params) { return (*reinterpret_cast
(callable))( std::forward
(params)...); } public: template
function_ref(Callable &&callable, typename std::enable_if< !std::is_same
::type, function_ref>::value>::type * = nullptr) : callback(callback_fn
::type>), callable(reinterpret_cast
(&callable)) {} Ret operator()(Params ...params) const { return callback(callable, std::forward
(params)...); } }; // deleter - Very very very simple method that is used to invoke operator // delete on something. It is used like this: // // for_each(V.begin(), B.end(), deleter
); // template
inline void deleter(T *Ptr) { delete Ptr; } //===----------------------------------------------------------------------===// // Extra additions to
//===----------------------------------------------------------------------===// // mapped_iterator - This is a simple iterator adapter that causes a function to // be applied whenever operator* is invoked on the iterator. // template
class mapped_iterator { RootIt current; UnaryFunc Fn; public: typedef typename std::iterator_traits
::iterator_category iterator_category; typedef typename std::iterator_traits
::difference_type difference_type; typedef decltype(std::declval
()(*std::declval
())) value_type; typedef void pointer; //typedef typename UnaryFunc::result_type *pointer; typedef void reference; // Can't modify value returned by fn typedef RootIt iterator_type; inline const RootIt &getCurrent() const { return current; } inline const UnaryFunc &getFunc() const { return Fn; } inline explicit mapped_iterator(const RootIt &I, UnaryFunc F) : current(I), Fn(F) {} inline value_type operator*() const { // All this work to do this return Fn(*current); // little change } mapped_iterator &operator++() { ++current; return *this; } mapped_iterator &operator--() { --current; return *this; } mapped_iterator operator++(int) { mapped_iterator __tmp = *this; ++current; return __tmp; } mapped_iterator operator--(int) { mapped_iterator __tmp = *this; --current; return __tmp; } mapped_iterator operator+(difference_type n) const { return mapped_iterator(current + n, Fn); } mapped_iterator &operator+=(difference_type n) { current += n; return *this; } mapped_iterator operator-(difference_type n) const { return mapped_iterator(current - n, Fn); } mapped_iterator &operator-=(difference_type n) { current -= n; return *this; } reference operator[](difference_type n) const { return *(*this + n); } bool operator!=(const mapped_iterator &X) const { return !operator==(X); } bool operator==(const mapped_iterator &X) const { return current == X.current; } bool operator<(const mapped_iterator &X) const { return current < X.current; } difference_type operator-(const mapped_iterator &X) const { return current - X.current; } }; template
inline mapped_iterator
operator+(typename mapped_iterator
::difference_type N, const mapped_iterator
&X) { return mapped_iterator
(X.getCurrent() - N, X.getFunc()); } // map_iterator - Provide a convenient way to create mapped_iterators, just like // make_pair is useful for creating pairs... // template
inline mapped_iterator
map_iterator(const ItTy &I, FuncTy F) { return mapped_iterator
(I, F); } /// Helper to determine if type T has a member called rbegin(). template
class has_rbegin_impl { typedef char yes[1]; typedef char no[2]; template
static yes& test(Inner *I, decltype(I->rbegin()) * = nullptr); template
static no& test(...); public: static const bool value = sizeof(test
(nullptr)) == sizeof(yes); }; /// Metafunction to determine if T& or T has a member called rbegin(). template
struct has_rbegin : has_rbegin_impl
::type> { }; // Returns an iterator_range over the given container which iterates in reverse. // Note that the container must have rbegin()/rend() methods for this to work. template
auto reverse(ContainerTy &&C, typename std::enable_if
::value>::type * = nullptr) -> decltype(make_range(C.rbegin(), C.rend())) { return make_range(C.rbegin(), C.rend()); } // Returns a std::reverse_iterator wrapped around the given iterator. template
std::reverse_iterator
make_reverse_iterator(IteratorTy It) { return std::reverse_iterator
(It); } // Returns an iterator_range over the given container which iterates in reverse. // Note that the container must have begin()/end() methods which return // bidirectional iterators for this to work. template
auto reverse( ContainerTy &&C, typename std::enable_if::value>::type * = nullptr) -> decltype(make_range(llvm::make_reverse_iterator(std::end(C)), llvm::make_reverse_iterator(std::begin(C)))) { return make_range(llvm::make_reverse_iterator(std::end(C)), llvm::make_reverse_iterator(std::begin(C))); } /// An iterator adaptor that filters the elements of given inner iterators. /// /// The predicate parameter should be a callable object that accepts the wrapped /// iterator's reference type and returns a bool. When incrementing or /// decrementing the iterator, it will call the predicate on each element and /// skip any where it returns false. /// /// \code /// int A[] = { 1, 2, 3, 4 }; /// auto R = make_filter_range(A, [](int N) { return N % 2 == 1; }); /// // R contains { 1, 3 }. /// \endcode template
class filter_iterator : public iterator_adaptor_base< filter_iterator
, WrappedIteratorT, typename std::common_type< std::forward_iterator_tag, typename std::iterator_traits< WrappedIteratorT>::iterator_category>::type> { using BaseT = iterator_adaptor_base< filter_iterator
, WrappedIteratorT, typename std::common_type< std::forward_iterator_tag, typename std::iterator_traits
::iterator_category>:: type>; struct PayloadType { WrappedIteratorT End; PredicateT Pred; }; Optional
Payload; void findNextValid() { assert(Payload && "Payload should be engaged when findNextValid is called"); while (this->I != Payload->End && !Payload->Pred(*this->I)) BaseT::operator++(); } // Construct the begin iterator. The begin iterator requires to know where end // is, so that it can properly stop when it hits end. filter_iterator(WrappedIteratorT Begin, WrappedIteratorT End, PredicateT Pred) : BaseT(std::move(Begin)), Payload(PayloadType{std::move(End), std::move(Pred)}) { findNextValid(); } // Construct the end iterator. It's not incrementable, so Payload doesn't // have to be engaged. filter_iterator(WrappedIteratorT End) : BaseT(End) {} public: using BaseT::operator++; filter_iterator &operator++() { BaseT::operator++(); findNextValid(); return *this; } template
friend iterator_range
, PT>> make_filter_range(RT &&, PT); }; /// Convenience function that takes a range of elements and a predicate, /// and return a new filter_iterator range. /// /// FIXME: Currently if RangeT && is a rvalue reference to a temporary, the /// lifetime of that temporary is not kept by the returned range object, and the /// temporary is going to be dropped on the floor after the make_iterator_range /// full expression that contains this function call. template
iterator_range
, PredicateT>> make_filter_range(RangeT &&Range, PredicateT Pred) { using FilterIteratorT = filter_iterator
, PredicateT>; return make_range(FilterIteratorT(std::begin(std::forward
(Range)), std::end(std::forward
(Range)), std::move(Pred)), FilterIteratorT(std::end(std::forward
(Range)))); } // forward declarations required by zip_shortest/zip_first template
bool all_of(R &&range, UnaryPredicate P); template
struct index_sequence; template
struct index_sequence_for; namespace detail { using std::declval; // We have to alias this since inlining the actual type at the usage site // in the parameter list of iterator_facade_base<> below ICEs MSVC 2017. template
struct ZipTupleType { typedef std::tuple
())...> type; }; template
using zip_traits = iterator_facade_base< ZipType, typename std::common_type
::iterator_category...>::type, // ^ TODO: Implement random access methods. typename ZipTupleType
::type, typename std::iterator_traits
>::type>::difference_type, // ^ FIXME: This follows boost::make_zip_iterator's assumption that all // inner iterators have the same difference_type. It would fail if, for // instance, the second field's difference_type were non-numeric while the // first is. typename ZipTupleType
::type *, typename ZipTupleType
::type>; template
struct zip_common : public zip_traits
{ using Base = zip_traits
; using value_type = typename Base::value_type; std::tuple
iterators; protected: template
value_type deref(index_sequence
) const { return value_type(*std::get
(iterators)...); } template
decltype(iterators) tup_inc(index_sequence
) const { return std::tuple
(std::next(std::get
(iterators))...); } template
decltype(iterators) tup_dec(index_sequence
) const { return std::tuple
(std::prev(std::get
(iterators))...); } public: zip_common(Iters &&... ts) : iterators(std::forward
(ts)...) {} value_type operator*() { return deref(index_sequence_for
{}); } const value_type operator*() const { return deref(index_sequence_for
{}); } ZipType &operator++() { iterators = tup_inc(index_sequence_for
{}); return *reinterpret_cast
(this); } ZipType &operator--() { static_assert(Base::IsBidirectional, "All inner iterators must be at least bidirectional."); iterators = tup_dec(index_sequence_for
{}); return *reinterpret_cast
(this); } }; template
struct zip_first : public zip_common
, Iters...> { using Base = zip_common
, Iters...>; bool operator==(const zip_first
&other) const { return std::get<0>(this->iterators) == std::get<0>(other.iterators); } zip_first(Iters &&... ts) : Base(std::forward
(ts)...) {} }; template
class zip_shortest : public zip_common
, Iters...> { template
bool test(const zip_shortest
&other, index_sequence
) const { return all_of(std::initializer_list
{std::get
(this->iterators) != std::get
(other.iterators)...}, identity
{}); } public: using Base = zip_common
, Iters...>; bool operator==(const zip_shortest
&other) const { return !test(other, index_sequence_for
{}); } zip_shortest(Iters &&... ts) : Base(std::forward
(ts)...) {} }; template
class ItType, typename... Args> class zippy { public: using iterator = ItType
()))...>; using iterator_category = typename iterator::iterator_category; using value_type = typename iterator::value_type; using difference_type = typename iterator::difference_type; using pointer = typename iterator::pointer; using reference = typename iterator::reference; private: std::tuple
ts; template
iterator begin_impl(index_sequence
) const { return iterator(std::begin(std::get
(ts))...); } template
iterator end_impl(index_sequence
) const { return iterator(std::end(std::get
(ts))...); } public: iterator begin() const { return begin_impl(index_sequence_for
{}); } iterator end() const { return end_impl(index_sequence_for
{}); } zippy(Args &&... ts_) : ts(std::forward
(ts_)...) {} }; } // End detail namespace /// zip iterator for two or more iteratable types. template
detail::zippy
zip(T &&t, U &&u, Args &&... args) { return detail::zippy
( std::forward
(t), std::forward
(u), std::forward
(args)...); } /// zip iterator that, for the sake of efficiency, assumes the first iteratee to /// be the shortest. template
detail::zippy
zip_first(T &&t, U &&u, Args &&... args) { return detail::zippy
( std::forward
(t), std::forward
(u), std::forward
(args)...); } /// Iterator wrapper that concatenates sequences together. /// /// This can concatenate different iterators, even with different types, into /// a single iterator provided the value types of all the concatenated /// iterators expose `reference` and `pointer` types that can be converted to /// `ValueT &` and `ValueT *` respectively. It doesn't support more /// interesting/customized pointer or reference types. /// /// Currently this only supports forward or higher iterator categories as /// inputs and always exposes a forward iterator interface. template
class concat_iterator : public iterator_facade_base
, std::forward_iterator_tag, ValueT> { typedef typename concat_iterator::iterator_facade_base BaseT; /// We store both the current and end iterators for each concatenated /// sequence in a tuple of pairs. /// /// Note that something like iterator_range seems nice at first here, but the /// range properties are of little benefit and end up getting in the way /// because we need to do mutation on the current iterators. std::tuple
...> IterPairs; /// Attempts to increment a specific iterator. /// /// Returns true if it was able to increment the iterator. Returns false if /// the iterator is already at the end iterator. template
bool incrementHelper() { auto &IterPair = std::get
(IterPairs); if (IterPair.first == IterPair.second) return false; ++IterPair.first; return true; } /// Increments the first non-end iterator. /// /// It is an error to call this with all iterators at the end. template
void increment(index_sequence
) { // Build a sequence of functions to increment each iterator if possible. bool (concat_iterator::*IncrementHelperFns[])() = { &concat_iterator::incrementHelper
...}; // Loop over them, and stop as soon as we succeed at incrementing one. for (auto &IncrementHelperFn : IncrementHelperFns) if ((this->*IncrementHelperFn)()) return; llvm_unreachable("Attempted to increment an end concat iterator!"); } /// Returns null if the specified iterator is at the end. Otherwise, /// dereferences the iterator and returns the address of the resulting /// reference. template
ValueT *getHelper() const { auto &IterPair = std::get
(IterPairs); if (IterPair.first == IterPair.second) return nullptr; return &*IterPair.first; } /// Finds the first non-end iterator, dereferences, and returns the resulting /// reference. /// /// It is an error to call this with all iterators at the end. template
ValueT &get(index_sequence
) const { // Build a sequence of functions to get from iterator if possible. ValueT *(concat_iterator::*GetHelperFns[])() const = { &concat_iterator::getHelper
...}; // Loop over them, and return the first result we find. for (auto &GetHelperFn : GetHelperFns) if (ValueT *P = (this->*GetHelperFn)()) return *P; llvm_unreachable("Attempted to get a pointer from an end concat iterator!"); } public: /// Constructs an iterator from a squence of ranges. /// /// We need the full range to know how to switch between each of the /// iterators. template
explicit concat_iterator(RangeTs &&... Ranges) : IterPairs({std::begin(Ranges), std::end(Ranges)}...) {} using BaseT::operator++; concat_iterator &operator++() { increment(index_sequence_for
()); return *this; } ValueT &operator*() const { return get(index_sequence_for
()); } bool operator==(const concat_iterator &RHS) const { return IterPairs == RHS.IterPairs; } }; namespace detail { /// Helper to store a sequence of ranges being concatenated and access them. /// /// This is designed to facilitate providing actual storage when temporaries /// are passed into the constructor such that we can use it as part of range /// based for loops. template
class concat_range { public: typedef concat_iterator
()))...> iterator; private: std::tuple
Ranges; template
iterator begin_impl(index_sequence
) { return iterator(std::get
(Ranges)...); } template
iterator end_impl(index_sequence
) { return iterator(make_range(std::end(std::get
(Ranges)), std::end(std::get
(Ranges)))...); } public: iterator begin() { return begin_impl(index_sequence_for
{}); } iterator end() { return end_impl(index_sequence_for
{}); } concat_range(RangeTs &&... Ranges) : Ranges(std::forward
(Ranges)...) {} }; } /// Concatenated range across two or more ranges. /// /// The desired value type must be explicitly specified. template
detail::concat_range
concat(RangeTs &&... Ranges) { static_assert(sizeof...(RangeTs) > 1, "Need more than one range to concatenate!"); return detail::concat_range
( std::forward
(Ranges)...); } //===----------------------------------------------------------------------===// // Extra additions to
//===----------------------------------------------------------------------===// /// \brief Function object to check whether the first component of a std::pair /// compares less than the first component of another std::pair. struct less_first { template
bool operator()(const T &lhs, const T &rhs) const { return lhs.first < rhs.first; } }; /// \brief Function object to check whether the second component of a std::pair /// compares less than the second component of another std::pair. struct less_second { template
bool operator()(const T &lhs, const T &rhs) const { return lhs.second < rhs.second; } }; // A subset of N3658. More stuff can be added as-needed. /// \brief Represents a compile-time sequence of integers. template
struct integer_sequence { typedef T value_type; static constexpr size_t size() { return sizeof...(I); } }; /// \brief Alias for the common case of a sequence of size_ts. template
struct index_sequence : integer_sequence
{}; template
struct build_index_impl : build_index_impl
{}; template
struct build_index_impl<0, I...> : index_sequence
{}; /// \brief Creates a compile-time integer sequence for a parameter pack. template
struct index_sequence_for : build_index_impl
{}; /// Utility type to build an inheritance chain that makes it easy to rank /// overload candidates. template
struct rank : rank
{}; template <> struct rank<0> {}; /// \brief traits class for checking whether type T is one of any of the given /// types in the variadic list. template
struct is_one_of { static const bool value = false; }; template
struct is_one_of
{ static const bool value = std::is_same
::value || is_one_of
::value; }; /// \brief traits class for checking whether type T is a base class for all /// the given types in the variadic list. template
struct are_base_of { static const bool value = true; }; template
struct are_base_of
{ static const bool value = std::is_base_of
::value && are_base_of
::value; }; //===----------------------------------------------------------------------===// // Extra additions for arrays //===----------------------------------------------------------------------===// /// Find the length of an array. template
constexpr inline size_t array_lengthof(T (&)[N]) { return N; } /// Adapt std::less
for array_pod_sort. template
inline int array_pod_sort_comparator(const void *P1, const void *P2) { if (std::less
()(*reinterpret_cast
(P1), *reinterpret_cast
(P2))) return -1; if (std::less
()(*reinterpret_cast
(P2), *reinterpret_cast
(P1))) return 1; return 0; } /// get_array_pod_sort_comparator - This is an internal helper function used to /// get type deduction of T right. template
inline int (*get_array_pod_sort_comparator(const T &)) (const void*, const void*) { return array_pod_sort_comparator
; } /// array_pod_sort - This sorts an array with the specified start and end /// extent. This is just like std::sort, except that it calls qsort instead of /// using an inlined template. qsort is slightly slower than std::sort, but /// most sorts are not performance critical in LLVM and std::sort has to be /// template instantiated for each type, leading to significant measured code /// bloat. This function should generally be used instead of std::sort where /// possible. /// /// This function assumes that you have simple POD-like types that can be /// compared with std::less and can be moved with memcpy. If this isn't true, /// you should use std::sort. /// /// NOTE: If qsort_r were portable, we could allow a custom comparator and /// default to std::less. template
inline void array_pod_sort(IteratorTy Start, IteratorTy End) { // Don't inefficiently call qsort with one element or trigger undefined // behavior with an empty sequence. auto NElts = End - Start; if (NElts <= 1) return; qsort(&*Start, NElts, sizeof(*Start), get_array_pod_sort_comparator(*Start)); } template
inline void array_pod_sort( IteratorTy Start, IteratorTy End, int (*Compare)( const typename std::iterator_traits
::value_type *, const typename std::iterator_traits
::value_type *)) { // Don't inefficiently call qsort with one element or trigger undefined // behavior with an empty sequence. auto NElts = End - Start; if (NElts <= 1) return; qsort(&*Start, NElts, sizeof(*Start), reinterpret_cast
(Compare)); } //===----------------------------------------------------------------------===// // Extra additions to
//===----------------------------------------------------------------------===// /// For a container of pointers, deletes the pointers and then clears the /// container. template
void DeleteContainerPointers(Container &C) { for (auto V : C) delete V; C.clear(); } /// In a container of pairs (usually a map) whose second element is a pointer, /// deletes the second elements and then clears the container. template
void DeleteContainerSeconds(Container &C) { for (auto &V : C) delete V.second; C.clear(); } /// Provide wrappers to std::all_of which take ranges instead of having to pass /// begin/end explicitly. template
bool all_of(R &&Range, UnaryPredicate P) { return std::all_of(std::begin(Range), std::end(Range), P); } /// Provide wrappers to std::any_of which take ranges instead of having to pass /// begin/end explicitly. template
bool any_of(R &&Range, UnaryPredicate P) { return std::any_of(std::begin(Range), std::end(Range), P); } /// Provide wrappers to std::none_of which take ranges instead of having to pass /// begin/end explicitly. template
bool none_of(R &&Range, UnaryPredicate P) { return std::none_of(std::begin(Range), std::end(Range), P); } /// Provide wrappers to std::find which take ranges instead of having to pass /// begin/end explicitly. template
auto find(R &&Range, const T &Val) -> decltype(std::begin(Range)) { return std::find(std::begin(Range), std::end(Range), Val); } /// Provide wrappers to std::find_if which take ranges instead of having to pass /// begin/end explicitly. template
auto find_if(R &&Range, UnaryPredicate P) -> decltype(std::begin(Range)) { return std::find_if(std::begin(Range), std::end(Range), P); } template
auto find_if_not(R &&Range, UnaryPredicate P) -> decltype(std::begin(Range)) { return std::find_if_not(std::begin(Range), std::end(Range), P); } /// Provide wrappers to std::remove_if which take ranges instead of having to /// pass begin/end explicitly. template
auto remove_if(R &&Range, UnaryPredicate P) -> decltype(std::begin(Range)) { return std::remove_if(std::begin(Range), std::end(Range), P); } /// Provide wrappers to std::copy_if which take ranges instead of having to /// pass begin/end explicitly. template
OutputIt copy_if(R &&Range, OutputIt Out, UnaryPredicate P) { return std::copy_if(std::begin(Range), std::end(Range), Out, P); } /// Wrapper function around std::find to detect if an element exists /// in a container. template
bool is_contained(R &&Range, const E &Element) { return std::find(std::begin(Range), std::end(Range), Element) != std::end(Range); } /// Wrapper function around std::count to count the number of times an element /// \p Element occurs in the given range \p Range. template
auto count(R &&Range, const E &Element) -> typename std::iterator_traits< decltype(std::begin(Range))>::difference_type { return std::count(std::begin(Range), std::end(Range), Element); } /// Wrapper function around std::count_if to count the number of times an /// element satisfying a given predicate occurs in a range. template
auto count_if(R &&Range, UnaryPredicate P) -> typename std::iterator_traits< decltype(std::begin(Range))>::difference_type { return std::count_if(std::begin(Range), std::end(Range), P); } /// Wrapper function around std::transform to apply a function to a range and /// store the result elsewhere. template
OutputIt transform(R &&Range, OutputIt d_first, UnaryPredicate P) { return std::transform(std::begin(Range), std::end(Range), d_first, P); } /// Provide wrappers to std::partition which take ranges instead of having to /// pass begin/end explicitly. template
auto partition(R &&Range, UnaryPredicate P) -> decltype(std::begin(Range)) { return std::partition(std::begin(Range), std::end(Range), P); } /// \brief Given a range of type R, iterate the entire range and return a /// SmallVector with elements of the vector. This is useful, for example, /// when you want to iterate a range and then sort the results. template
SmallVector
>::type, Size> to_vector(R &&Range) { return {std::begin(Range), std::end(Range)}; } /// Provide a container algorithm similar to C++ Library Fundamentals v2's /// `erase_if` which is equivalent to: /// /// C.erase(remove_if(C, pred), C.end()); /// /// This version works for any container with an erase method call accepting /// two iterators. template
void erase_if(Container &C, UnaryPredicate P) { C.erase(remove_if(C, P), C.end()); } //===----------------------------------------------------------------------===// // Extra additions to
//===----------------------------------------------------------------------===// // Implement make_unique according to N3656. /// \brief Constructs a `new T()` with the given args and returns a /// `unique_ptr
` which owns the object. /// /// Example: /// /// auto p = make_unique
(); /// auto p = make_unique
>(0, 1); template
typename std::enable_if::value, std::unique_ptr
>::type make_unique(Args &&... args) { return std::unique_ptr
(new T(std::forward
(args)...)); } /// \brief Constructs a `new T[n]` with the given args and returns a /// `unique_ptr
` which owns the object. /// /// \param n size of the new array. /// /// Example: /// /// auto p = make_unique
(2); // value-initializes the array with 0's. template
typename std::enable_if
::value && std::extent