LCOV - code coverage report
Current view: top level - usr/include/c++/6/bits - unique_ptr.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 35 40 87.5 %
Date: 2018-11-14 16:53:58 Functions: 21 33 63.6 %

          Line data    Source code
       1             : // unique_ptr implementation -*- C++ -*-
       2             : 
       3             : // Copyright (C) 2008-2016 Free Software Foundation, Inc.
       4             : //
       5             : // This file is part of the GNU ISO C++ Library.  This library is free
       6             : // software; you can redistribute it and/or modify it under the
       7             : // terms of the GNU General Public License as published by the
       8             : // Free Software Foundation; either version 3, or (at your option)
       9             : // any later version.
      10             : 
      11             : // This library is distributed in the hope that it will be useful,
      12             : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             : // GNU General Public License for more details.
      15             : 
      16             : // Under Section 7 of GPL version 3, you are granted additional
      17             : // permissions described in the GCC Runtime Library Exception, version
      18             : // 3.1, as published by the Free Software Foundation.
      19             : 
      20             : // You should have received a copy of the GNU General Public License and
      21             : // a copy of the GCC Runtime Library Exception along with this program;
      22             : // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
      23             : // <http://www.gnu.org/licenses/>.
      24             : 
      25             : /** @file bits/unique_ptr.h
      26             :  *  This is an internal header file, included by other library headers.
      27             :  *  Do not attempt to use it directly. @headername{memory}
      28             :  */
      29             : 
      30             : #ifndef _UNIQUE_PTR_H
      31             : #define _UNIQUE_PTR_H 1
      32             : 
      33             : #include <bits/c++config.h>
      34             : #include <debug/assertions.h>
      35             : #include <type_traits>
      36             : #include <utility>
      37             : #include <tuple>
      38             : 
      39             : namespace std _GLIBCXX_VISIBILITY(default)
      40             : {
      41             : _GLIBCXX_BEGIN_NAMESPACE_VERSION
      42             : 
      43             :   /**
      44             :    * @addtogroup pointer_abstractions
      45             :    * @{
      46             :    */
      47             : 
      48             : #if _GLIBCXX_USE_DEPRECATED
      49             :   template<typename> class auto_ptr;
      50             : #endif
      51             : 
      52             :   /// Primary template of default_delete, used by unique_ptr
      53             :   template<typename _Tp>
      54             :     struct default_delete
      55             :     {
      56             :       /// Default constructor
      57         187 :       constexpr default_delete() noexcept = default;
      58             : 
      59             :       /** @brief Converting constructor.
      60             :        *
      61             :        * Allows conversion from a deleter for arrays of another type, @p _Up,
      62             :        * only if @p _Up* is convertible to @p _Tp*.
      63             :        */
      64             :       template<typename _Up, typename = typename
      65             :                enable_if<is_convertible<_Up*, _Tp*>::value>::type>
      66             :         default_delete(const default_delete<_Up>&) noexcept { }
      67             : 
      68             :       /// Calls @c delete @p __ptr
      69             :       void
      70           4 :       operator()(_Tp* __ptr) const
      71             :       {
      72             :         static_assert(!is_void<_Tp>::value,
      73             :                       "can't delete pointer to incomplete type");
      74             :         static_assert(sizeof(_Tp)>0,
      75             :                       "can't delete pointer to incomplete type");
      76           4 :         delete __ptr;
      77           4 :       }
      78             :     };
      79             : 
      80             :   // _GLIBCXX_RESOLVE_LIB_DEFECTS
      81             :   // DR 740 - omit specialization for array objects with a compile time length
      82             :   /// Specialization for arrays, default_delete.
      83             :   template<typename _Tp>
      84             :     struct default_delete<_Tp[]>
      85             :     {
      86             :     public:
      87             :       /// Default constructor
      88             :       constexpr default_delete() noexcept = default;
      89             : 
      90             :       /** @brief Converting constructor.
      91             :        *
      92             :        * Allows conversion from a deleter for arrays of another type, such as
      93             :        * a const-qualified version of @p _Tp.
      94             :        *
      95             :        * Conversions from types derived from @c _Tp are not allowed because
      96             :        * it is unsafe to @c delete[] an array of derived types through a
      97             :        * pointer to the base type.
      98             :        */
      99             :       template<typename _Up, typename = typename
     100             :                enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type>
     101             :         default_delete(const default_delete<_Up[]>&) noexcept { }
     102             : 
     103             :       /// Calls @c delete[] @p __ptr
     104             :       template<typename _Up>
     105             :       typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
     106             :         operator()(_Up* __ptr) const
     107             :       {
     108             :         static_assert(sizeof(_Tp)>0,
     109             :                       "can't delete pointer to incomplete type");
     110             :         delete [] __ptr;
     111             :       }
     112             :     };
     113             : 
     114             :   /// 20.7.1.2 unique_ptr for single objects.
     115             :   template <typename _Tp, typename _Dp = default_delete<_Tp> >
     116             :     class unique_ptr
     117             :     {
     118             :       // use SFINAE to determine whether _Del::pointer exists
     119             :       class _Pointer
     120             :       {
     121             :         template<typename _Up>
     122             :           static typename _Up::pointer __test(typename _Up::pointer*);
     123             : 
     124             :         template<typename _Up>
     125             :           static _Tp* __test(...);
     126             : 
     127             :         typedef typename remove_reference<_Dp>::type _Del;
     128             : 
     129             :       public:
     130             :         typedef decltype(__test<_Del>(0)) type;
     131             :       };
     132             : 
     133             :       typedef std::tuple<typename _Pointer::type, _Dp>  __tuple_type;
     134             :       __tuple_type                                      _M_t;
     135             : 
     136             :     public:
     137             :       typedef typename _Pointer::type   pointer;
     138             :       typedef _Tp                       element_type;
     139             :       typedef _Dp                       deleter_type;
     140             : 
     141             : 
     142             :       // helper template for detecting a safe conversion from another
     143             :       // unique_ptr
     144             :       template<typename _Up, typename _Ep>
     145             :         using __safe_conversion_up = __and_<
     146             :                 is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
     147             :                 __not_<is_array<_Up>>,
     148             :                 __or_<__and_<is_reference<deleter_type>,
     149             :                              is_same<deleter_type, _Ep>>,
     150             :                       __and_<__not_<is_reference<deleter_type>>,
     151             :                              is_convertible<_Ep, deleter_type>>
     152             :                 >
     153             :               >;
     154             : 
     155             :       // Constructors.
     156             : 
     157             :       /// Default constructor, creates a unique_ptr that owns nothing.
     158         183 :       constexpr unique_ptr() noexcept
     159         183 :       : _M_t()
     160             :       { static_assert(!is_pointer<deleter_type>::value,
     161         183 :                      "constructed with null function pointer deleter"); }
     162             : 
     163             :       /** Takes ownership of a pointer.
     164             :        *
     165             :        * @param __p  A pointer to an object of @c element_type
     166             :        *
     167             :        * The deleter will be value-initialized.
     168             :        */
     169             :       explicit
     170           4 :       unique_ptr(pointer __p) noexcept
     171           4 :       : _M_t()
     172             :       {
     173           4 :         std::get<0>(_M_t) = __p;
     174             :         static_assert(!is_pointer<deleter_type>::value,
     175             :                      "constructed with null function pointer deleter");
     176           4 :       }
     177             : 
     178             :       /** Takes ownership of a pointer.
     179             :        *
     180             :        * @param __p  A pointer to an object of @c element_type
     181             :        * @param __d  A reference to a deleter.
     182             :        *
     183             :        * The deleter will be initialized with @p __d
     184             :        */
     185             :       unique_ptr(pointer __p,
     186             :           typename conditional<is_reference<deleter_type>::value,
     187             :             deleter_type, const deleter_type&>::type __d) noexcept
     188             :       : _M_t(__p, __d) { }
     189             : 
     190             :       /** Takes ownership of a pointer.
     191             :        *
     192             :        * @param __p  A pointer to an object of @c element_type
     193             :        * @param __d  An rvalue reference to a deleter.
     194             :        *
     195             :        * The deleter will be initialized with @p std::move(__d)
     196             :        */
     197             :       unique_ptr(pointer __p,
     198             :           typename remove_reference<deleter_type>::type&& __d) noexcept
     199             :       : _M_t(std::move(__p), std::move(__d))
     200             :       { static_assert(!std::is_reference<deleter_type>::value,
     201             :                       "rvalue deleter bound to reference"); }
     202             : 
     203             :       /// Creates a unique_ptr that owns nothing.
     204             :       constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
     205             : 
     206             :       // Move constructors.
     207             : 
     208             :       /// Move constructor.
     209           0 :       unique_ptr(unique_ptr&& __u) noexcept
     210           0 :       : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
     211             : 
     212             :       /** @brief Converting constructor from another type
     213             :        *
     214             :        * Requires that the pointer owned by @p __u is convertible to the
     215             :        * type of pointer owned by this object, @p __u does not own an array,
     216             :        * and @p __u has a compatible deleter type.
     217             :        */
     218             :       template<typename _Up, typename _Ep, typename = _Require<
     219             :                __safe_conversion_up<_Up, _Ep>,
     220             :                typename conditional<is_reference<_Dp>::value,
     221             :                                     is_same<_Ep, _Dp>,
     222             :                                     is_convertible<_Ep, _Dp>>::type>>
     223             :         unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
     224             :         : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
     225             :         { }
     226             : 
     227             : #if _GLIBCXX_USE_DEPRECATED
     228             :       /// Converting constructor from @c auto_ptr
     229             :       template<typename _Up, typename = _Require<
     230             :                is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
     231             :         unique_ptr(auto_ptr<_Up>&& __u) noexcept;
     232             : #endif
     233             : 
     234             :       /// Destructor, invokes the deleter if the stored pointer is not null.
     235         187 :       ~unique_ptr() noexcept
     236             :       {
     237         187 :         auto& __ptr = std::get<0>(_M_t);
     238         187 :         if (__ptr != nullptr)
     239           4 :           get_deleter()(__ptr);
     240         187 :         __ptr = pointer();
     241         187 :       }
     242             : 
     243             :       // Assignment.
     244             : 
     245             :       /** @brief Move assignment operator.
     246             :        *
     247             :        * @param __u  The object to transfer ownership from.
     248             :        *
     249             :        * Invokes the deleter first if this object owns a pointer.
     250             :        */
     251             :       unique_ptr&
     252           2 :       operator=(unique_ptr&& __u) noexcept
     253             :       {
     254           2 :         reset(__u.release());
     255           2 :         get_deleter() = std::forward<deleter_type>(__u.get_deleter());
     256           2 :         return *this;
     257             :       }
     258             : 
     259             :       /** @brief Assignment from another type.
     260             :        *
     261             :        * @param __u  The object to transfer ownership from, which owns a
     262             :        *             convertible pointer to a non-array object.
     263             :        *
     264             :        * Invokes the deleter first if this object owns a pointer.
     265             :        */
     266             :       template<typename _Up, typename _Ep>
     267             :         typename enable_if< __and_<
     268             :           __safe_conversion_up<_Up, _Ep>,
     269             :           is_assignable<deleter_type&, _Ep&&>
     270             :           >::value,
     271             :           unique_ptr&>::type
     272             :         operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
     273             :         {
     274             :           reset(__u.release());
     275             :           get_deleter() = std::forward<_Ep>(__u.get_deleter());
     276             :           return *this;
     277             :         }
     278             : 
     279             :       /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
     280             :       unique_ptr&
     281             :       operator=(nullptr_t) noexcept
     282             :       {
     283             :         reset();
     284             :         return *this;
     285             :       }
     286             : 
     287             :       // Observers.
     288             : 
     289             :       /// Dereference the stored pointer.
     290             :       typename add_lvalue_reference<element_type>::type
     291             :       operator*() const
     292             :       {
     293             :         __glibcxx_assert(get() != pointer());
     294             :         return *get();
     295             :       }
     296             : 
     297             :       /// Return the stored pointer.
     298             :       pointer
     299           6 :       operator->() const noexcept
     300             :       {
     301             :         _GLIBCXX_DEBUG_PEDASSERT(get() != pointer());
     302           6 :         return get();
     303             :       }
     304             : 
     305             :       /// Return the stored pointer.
     306             :       pointer
     307          12 :       get() const noexcept
     308          12 :       { return std::get<0>(_M_t); }
     309             : 
     310             :       /// Return a reference to the stored deleter.
     311             :       deleter_type&
     312           8 :       get_deleter() noexcept
     313           8 :       { return std::get<1>(_M_t); }
     314             : 
     315             :       /// Return a reference to the stored deleter.
     316             :       const deleter_type&
     317             :       get_deleter() const noexcept
     318             :       { return std::get<1>(_M_t); }
     319             : 
     320             :       /// Return @c true if the stored pointer is not null.
     321           0 :       explicit operator bool() const noexcept
     322           0 :       { return get() == pointer() ? false : true; }
     323             : 
     324             :       // Modifiers.
     325             : 
     326             :       /// Release ownership of any stored pointer.
     327             :       pointer
     328           2 :       release() noexcept
     329             :       {
     330           2 :         pointer __p = get();
     331           2 :         std::get<0>(_M_t) = pointer();
     332           2 :         return __p;
     333             :       }
     334             : 
     335             :       /** @brief Replace the stored pointer.
     336             :        *
     337             :        * @param __p  The new pointer to store.
     338             :        *
     339             :        * The deleter will be invoked if a pointer is already owned.
     340             :        */
     341             :       void
     342           2 :       reset(pointer __p = pointer()) noexcept
     343             :       {
     344             :         using std::swap;
     345           2 :         swap(std::get<0>(_M_t), __p);
     346           2 :         if (__p != pointer())
     347           0 :           get_deleter()(__p);
     348           2 :       }
     349             : 
     350             :       /// Exchange the pointer and deleter with another object.
     351             :       void
     352             :       swap(unique_ptr& __u) noexcept
     353             :       {
     354             :         using std::swap;
     355             :         swap(_M_t, __u._M_t);
     356             :       }
     357             : 
     358             :       // Disable copy from lvalue.
     359             :       unique_ptr(const unique_ptr&) = delete;
     360             :       unique_ptr& operator=(const unique_ptr&) = delete;
     361             :   };
     362             : 
     363             :   /// 20.7.1.3 unique_ptr for array objects with a runtime length
     364             :   // [unique.ptr.runtime]
     365             :   // _GLIBCXX_RESOLVE_LIB_DEFECTS
     366             :   // DR 740 - omit specialization for array objects with a compile time length
     367             :   template<typename _Tp, typename _Dp>
     368             :     class unique_ptr<_Tp[], _Dp>
     369             :     {
     370             :       // use SFINAE to determine whether _Del::pointer exists
     371             :       class _Pointer
     372             :       {
     373             :         template<typename _Up>
     374             :           static typename _Up::pointer __test(typename _Up::pointer*);
     375             : 
     376             :         template<typename _Up>
     377             :           static _Tp* __test(...);
     378             : 
     379             :         typedef typename remove_reference<_Dp>::type _Del;
     380             : 
     381             :       public:
     382             :         typedef decltype(__test<_Del>(0)) type;
     383             :       };
     384             : 
     385             :       typedef std::tuple<typename _Pointer::type, _Dp>  __tuple_type;
     386             :       __tuple_type                                      _M_t;
     387             : 
     388             :       template<typename _Up>
     389             :         using __remove_cv = typename remove_cv<_Up>::type;
     390             : 
     391             :       // like is_base_of<_Tp, _Up> but false if unqualified types are the same
     392             :       template<typename _Up>
     393             :         using __is_derived_Tp
     394             :           = __and_< is_base_of<_Tp, _Up>,
     395             :                     __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
     396             : 
     397             : 
     398             :     public:
     399             :       typedef typename _Pointer::type   pointer;
     400             :       typedef _Tp                       element_type;
     401             :       typedef _Dp                       deleter_type;
     402             : 
     403             :       // helper template for detecting a safe conversion from another
     404             :       // unique_ptr
     405             :       template<typename _Up, typename _Ep,
     406             :                typename _Up_up = unique_ptr<_Up, _Ep>,
     407             :                typename _Up_element_type = typename _Up_up::element_type>
     408             :         using __safe_conversion_up = __and_<
     409             :           is_array<_Up>,
     410             :           is_same<pointer, element_type*>,
     411             :           is_same<typename _Up_up::pointer, _Up_element_type*>,
     412             :           is_convertible<_Up_element_type(*)[], element_type(*)[]>,
     413             :           __or_<__and_<is_reference<deleter_type>, is_same<deleter_type, _Ep>>,
     414             :                 __and_<__not_<is_reference<deleter_type>>,
     415             :                        is_convertible<_Ep, deleter_type>>>
     416             :         >;
     417             : 
     418             :       // helper template for detecting a safe conversion from a raw pointer
     419             :       template<typename _Up>
     420             :         using __safe_conversion_raw = __and_<
     421             :           __or_<__or_<is_same<_Up, pointer>,
     422             :                       is_same<_Up, nullptr_t>>,
     423             :                 __and_<is_pointer<_Up>,
     424             :                        is_same<pointer, element_type*>,
     425             :                        is_convertible<
     426             :                          typename remove_pointer<_Up>::type(*)[],
     427             :                          element_type(*)[]>
     428             :                 >
     429             :           >
     430             :         >;
     431             : 
     432             :       // Constructors.
     433             : 
     434             :       /// Default constructor, creates a unique_ptr that owns nothing.
     435             :       constexpr unique_ptr() noexcept
     436             :       : _M_t()
     437             :       { static_assert(!std::is_pointer<deleter_type>::value,
     438             :                       "constructed with null function pointer deleter"); }
     439             : 
     440             :       /** Takes ownership of a pointer.
     441             :        *
     442             :        * @param __p  A pointer to an array of a type safely convertible
     443             :        * to an array of @c element_type
     444             :        *
     445             :        * The deleter will be value-initialized.
     446             :        */
     447             :       template<typename _Up,
     448             :                typename = typename enable_if<
     449             :                  __safe_conversion_raw<_Up>::value, bool>::type>
     450             :       explicit
     451             :       unique_ptr(_Up __p) noexcept
     452             :       : _M_t(__p, deleter_type())
     453             :       { static_assert(!is_pointer<deleter_type>::value,
     454             :                       "constructed with null function pointer deleter"); }
     455             : 
     456             :       /** Takes ownership of a pointer.
     457             :        *
     458             :        * @param __p  A pointer to an array of a type safely convertible
     459             :        * to an array of @c element_type
     460             :        * @param __d  A reference to a deleter.
     461             :        *
     462             :        * The deleter will be initialized with @p __d
     463             :        */
     464             :       template<typename _Up,
     465             :                typename = typename enable_if<
     466             :                  __safe_conversion_raw<_Up>::value, bool>::type>
     467             :       unique_ptr(_Up __p,
     468             :                  typename conditional<is_reference<deleter_type>::value,
     469             :                  deleter_type, const deleter_type&>::type __d) noexcept
     470             :       : _M_t(__p, __d) { }
     471             : 
     472             :       /** Takes ownership of a pointer.
     473             :        *
     474             :        * @param __p  A pointer to an array of a type safely convertible
     475             :        * to an array of @c element_type
     476             :        * @param __d  A reference to a deleter.
     477             :        *
     478             :        * The deleter will be initialized with @p std::move(__d)
     479             :        */
     480             :       template<typename _Up,
     481             :                typename = typename enable_if<
     482             :                  __safe_conversion_raw<_Up>::value, bool>::type>
     483             :       unique_ptr(_Up __p, typename
     484             :                  remove_reference<deleter_type>::type&& __d) noexcept
     485             :       : _M_t(std::move(__p), std::move(__d))
     486             :       { static_assert(!is_reference<deleter_type>::value,
     487             :                       "rvalue deleter bound to reference"); }
     488             : 
     489             :       /// Move constructor.
     490             :       unique_ptr(unique_ptr&& __u) noexcept
     491             :       : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
     492             : 
     493             :       /// Creates a unique_ptr that owns nothing.
     494             :       constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
     495             : 
     496             :       template<typename _Up, typename _Ep,
     497             :                typename = _Require<__safe_conversion_up<_Up, _Ep>>>
     498             :         unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
     499             :         : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
     500             :         { }
     501             : 
     502             :       /// Destructor, invokes the deleter if the stored pointer is not null.
     503             :       ~unique_ptr()
     504             :       {
     505             :         auto& __ptr = std::get<0>(_M_t);
     506             :         if (__ptr != nullptr)
     507             :           get_deleter()(__ptr);
     508             :         __ptr = pointer();
     509             :       }
     510             : 
     511             :       // Assignment.
     512             : 
     513             :       /** @brief Move assignment operator.
     514             :        *
     515             :        * @param __u  The object to transfer ownership from.
     516             :        *
     517             :        * Invokes the deleter first if this object owns a pointer.
     518             :        */
     519             :       unique_ptr&
     520             :       operator=(unique_ptr&& __u) noexcept
     521             :       {
     522             :         reset(__u.release());
     523             :         get_deleter() = std::forward<deleter_type>(__u.get_deleter());
     524             :         return *this;
     525             :       }
     526             : 
     527             :       /** @brief Assignment from another type.
     528             :        *
     529             :        * @param __u  The object to transfer ownership from, which owns a
     530             :        *             convertible pointer to an array object.
     531             :        *
     532             :        * Invokes the deleter first if this object owns a pointer.
     533             :        */
     534             :       template<typename _Up, typename _Ep>
     535             :         typename
     536             :         enable_if<__and_<__safe_conversion_up<_Up, _Ep>,
     537             :                          is_assignable<deleter_type&, _Ep&&>
     538             :                   >::value,
     539             :                   unique_ptr&>::type
     540             :         operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
     541             :         {
     542             :           reset(__u.release());
     543             :           get_deleter() = std::forward<_Ep>(__u.get_deleter());
     544             :           return *this;
     545             :         }
     546             : 
     547             :       /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
     548             :       unique_ptr&
     549             :       operator=(nullptr_t) noexcept
     550             :       {
     551             :         reset();
     552             :         return *this;
     553             :       }
     554             : 
     555             :       // Observers.
     556             : 
     557             :       /// Access an element of owned array.
     558             :       typename std::add_lvalue_reference<element_type>::type
     559             :       operator[](size_t __i) const
     560             :       {
     561             :         __glibcxx_assert(get() != pointer());
     562             :         return get()[__i];
     563             :       }
     564             : 
     565             :       /// Return the stored pointer.
     566             :       pointer
     567             :       get() const noexcept
     568             :       { return std::get<0>(_M_t); }
     569             : 
     570             :       /// Return a reference to the stored deleter.
     571             :       deleter_type&
     572             :       get_deleter() noexcept
     573             :       { return std::get<1>(_M_t); }
     574             : 
     575             :       /// Return a reference to the stored deleter.
     576             :       const deleter_type&
     577             :       get_deleter() const noexcept
     578             :       { return std::get<1>(_M_t); }
     579             : 
     580             :       /// Return @c true if the stored pointer is not null.
     581             :       explicit operator bool() const noexcept
     582             :       { return get() == pointer() ? false : true; }
     583             : 
     584             :       // Modifiers.
     585             : 
     586             :       /// Release ownership of any stored pointer.
     587             :       pointer
     588             :       release() noexcept
     589             :       {
     590             :         pointer __p = get();
     591             :         std::get<0>(_M_t) = pointer();
     592             :         return __p;
     593             :       }
     594             : 
     595             :       /** @brief Replace the stored pointer.
     596             :        *
     597             :        * @param __p  The new pointer to store.
     598             :        *
     599             :        * The deleter will be invoked if a pointer is already owned.
     600             :        */
     601             :       template <typename _Up,
     602             :                 typename = _Require<
     603             :                   __or_<is_same<_Up, pointer>,
     604             :                         __and_<is_same<pointer, element_type*>,
     605             :                                is_pointer<_Up>,
     606             :                                is_convertible<
     607             :                                  typename remove_pointer<_Up>::type(*)[],
     608             :                                  element_type(*)[]
     609             :                                >
     610             :                         >
     611             :                   >
     612             :                >>
     613             :       void
     614             :       reset(_Up __p) noexcept
     615             :       {
     616             :         pointer __ptr = __p;
     617             :         using std::swap;
     618             :         swap(std::get<0>(_M_t), __ptr);
     619             :         if (__ptr != nullptr)
     620             :           get_deleter()(__ptr);
     621             :       }
     622             : 
     623             :       void reset(nullptr_t = nullptr) noexcept
     624             :       {
     625             :         reset(pointer());
     626             :       }
     627             : 
     628             :       /// Exchange the pointer and deleter with another object.
     629             :       void
     630             :       swap(unique_ptr& __u) noexcept
     631             :       {
     632             :         using std::swap;
     633             :         swap(_M_t, __u._M_t);
     634             :       }
     635             : 
     636             :       // Disable copy from lvalue.
     637             :       unique_ptr(const unique_ptr&) = delete;
     638             :       unique_ptr& operator=(const unique_ptr&) = delete;
     639             :     };
     640             : 
     641             :   template<typename _Tp, typename _Dp>
     642             :     inline void
     643             :     swap(unique_ptr<_Tp, _Dp>& __x,
     644             :          unique_ptr<_Tp, _Dp>& __y) noexcept
     645             :     { __x.swap(__y); }
     646             : 
     647             :   template<typename _Tp, typename _Dp,
     648             :            typename _Up, typename _Ep>
     649             :     inline bool
     650             :     operator==(const unique_ptr<_Tp, _Dp>& __x,
     651             :                const unique_ptr<_Up, _Ep>& __y)
     652             :     { return __x.get() == __y.get(); }
     653             : 
     654             :   template<typename _Tp, typename _Dp>
     655             :     inline bool
     656             :     operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
     657             :     { return !__x; }
     658             : 
     659             :   template<typename _Tp, typename _Dp>
     660             :     inline bool
     661             :     operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
     662             :     { return !__x; }
     663             : 
     664             :   template<typename _Tp, typename _Dp,
     665             :            typename _Up, typename _Ep>
     666             :     inline bool
     667             :     operator!=(const unique_ptr<_Tp, _Dp>& __x,
     668             :                const unique_ptr<_Up, _Ep>& __y)
     669             :     { return __x.get() != __y.get(); }
     670             : 
     671             :   template<typename _Tp, typename _Dp>
     672             :     inline bool
     673             :     operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
     674             :     { return (bool)__x; }
     675             : 
     676             :   template<typename _Tp, typename _Dp>
     677             :     inline bool
     678             :     operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
     679             :     { return (bool)__x; }
     680             : 
     681             :   template<typename _Tp, typename _Dp,
     682             :            typename _Up, typename _Ep>
     683             :     inline bool
     684             :     operator<(const unique_ptr<_Tp, _Dp>& __x,
     685             :               const unique_ptr<_Up, _Ep>& __y)
     686             :     {
     687             :       typedef typename
     688             :         std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
     689             :                          typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
     690             :       return std::less<_CT>()(__x.get(), __y.get());
     691             :     }
     692             : 
     693             :   template<typename _Tp, typename _Dp>
     694             :     inline bool
     695             :     operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
     696             :     { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
     697             :                                                                  nullptr); }
     698             : 
     699             :   template<typename _Tp, typename _Dp>
     700             :     inline bool
     701             :     operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
     702             :     { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
     703             :                                                                  __x.get()); }
     704             : 
     705             :   template<typename _Tp, typename _Dp,
     706             :            typename _Up, typename _Ep>
     707             :     inline bool
     708             :     operator<=(const unique_ptr<_Tp, _Dp>& __x,
     709             :                const unique_ptr<_Up, _Ep>& __y)
     710             :     { return !(__y < __x); }
     711             : 
     712             :   template<typename _Tp, typename _Dp>
     713             :     inline bool
     714             :     operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
     715             :     { return !(nullptr < __x); }
     716             : 
     717             :   template<typename _Tp, typename _Dp>
     718             :     inline bool
     719             :     operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
     720             :     { return !(__x < nullptr); }
     721             : 
     722             :   template<typename _Tp, typename _Dp,
     723             :            typename _Up, typename _Ep>
     724             :     inline bool
     725             :     operator>(const unique_ptr<_Tp, _Dp>& __x,
     726             :               const unique_ptr<_Up, _Ep>& __y)
     727             :     { return (__y < __x); }
     728             : 
     729             :   template<typename _Tp, typename _Dp>
     730             :     inline bool
     731             :     operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
     732             :     { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
     733             :                                                                  __x.get()); }
     734             : 
     735             :   template<typename _Tp, typename _Dp>
     736             :     inline bool
     737             :     operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
     738             :     { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
     739             :                                                                  nullptr); }
     740             : 
     741             :   template<typename _Tp, typename _Dp,
     742             :            typename _Up, typename _Ep>
     743             :     inline bool
     744             :     operator>=(const unique_ptr<_Tp, _Dp>& __x,
     745             :                const unique_ptr<_Up, _Ep>& __y)
     746             :     { return !(__x < __y); }
     747             : 
     748             :   template<typename _Tp, typename _Dp>
     749             :     inline bool
     750             :     operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
     751             :     { return !(__x < nullptr); }
     752             : 
     753             :   template<typename _Tp, typename _Dp>
     754             :     inline bool
     755             :     operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
     756             :     { return !(nullptr < __x); }
     757             : 
     758             :   /// std::hash specialization for unique_ptr.
     759             :   template<typename _Tp, typename _Dp>
     760             :     struct hash<unique_ptr<_Tp, _Dp>>
     761             :     : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>
     762             :     {
     763             :       size_t
     764             :       operator()(const unique_ptr<_Tp, _Dp>& __u) const noexcept
     765             :       {
     766             :         typedef unique_ptr<_Tp, _Dp> _UP;
     767             :         return std::hash<typename _UP::pointer>()(__u.get());
     768             :       }
     769             :     };
     770             : 
     771             : #if __cplusplus > 201103L
     772             : 
     773             : #define __cpp_lib_make_unique 201304
     774             : 
     775             :   template<typename _Tp>
     776             :     struct _MakeUniq
     777             :     { typedef unique_ptr<_Tp> __single_object; };
     778             : 
     779             :   template<typename _Tp>
     780             :     struct _MakeUniq<_Tp[]>
     781             :     { typedef unique_ptr<_Tp[]> __array; };
     782             : 
     783             :   template<typename _Tp, size_t _Bound>
     784             :     struct _MakeUniq<_Tp[_Bound]>
     785             :     { struct __invalid_type { }; };
     786             : 
     787             :   /// std::make_unique for single objects
     788             :   template<typename _Tp, typename... _Args>
     789             :     inline typename _MakeUniq<_Tp>::__single_object
     790             :     make_unique(_Args&&... __args)
     791             :     { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
     792             : 
     793             :   /// std::make_unique for arrays of unknown bound
     794             :   template<typename _Tp>
     795             :     inline typename _MakeUniq<_Tp>::__array
     796             :     make_unique(size_t __num)
     797             :     { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }
     798             : 
     799             :   /// Disable std::make_unique for arrays of known bound
     800             :   template<typename _Tp, typename... _Args>
     801             :     inline typename _MakeUniq<_Tp>::__invalid_type
     802             :     make_unique(_Args&&...) = delete;
     803             : #endif
     804             : 
     805             :   // @} group pointer_abstractions
     806             : 
     807             : _GLIBCXX_END_NAMESPACE_VERSION
     808             : } // namespace
     809             : 
     810             : #endif /* _UNIQUE_PTR_H */

Generated by: LCOV version 1.13