framework/delibs/decpp/deUniquePtr.hpp

   1 #ifndef _DEUNIQUEPTR_HPP
   2 #define _DEUNIQUEPTR_HPP
   3 /*-------------------------------------------------------------------------
   4  * drawElements C++ Base Library
   5  * -----------------------------
   6  *
   7  * Copyright 2014 The Android Open Source Project
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  *//*!
  22  * \file
  23  * \brief Unique pointer.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "deDefs.hpp"
  27
  28 namespace de
  29 {
  30
  31 //! Unique pointer self-test.
  32 void UniquePtr_selfTest (void);
  33
  34 // Hide implementation-private types in a details namespace.
  35 namespace details
  36 {
  37
  38 //! Auxiliary struct used to pass references between unique pointers. To
  39 //! ensure that managed pointers are deleted exactly once, this type should
  40 //! not appear in user code.
  41 template<typename T, class D>
  42 struct PtrData
  43 {
  44                                 PtrData (T* p, D d) : ptr(p), deleter(d) {}
  45
  46                                 template <typename T2, class D2>
  47                                 PtrData (const PtrData<T2, D2>& d) : ptr(d.ptr), deleter(d.deleter) {}
  48
  49         T*                      ptr;
  50         D                       deleter;
  51 };
  52
  53 template<typename T, class D>
  54 class UniqueBase
  55 {
  56 public:
  57         typedef                 T                               element_type;
  58         typedef                 D                               deleter_type;
  59
  60         T*                              get                             (void) const throw() { return m_data.ptr;       }       //!< Get stored pointer.
  61         D                               getDeleter              (void) const throw() { return m_data.deleter; }
  62         T*                              operator->              (void) const throw() { return get();    }       //!< Get stored pointer.
  63         T&                              operator*               (void) const throw() { return *get();   }       //!< De-reference stored pointer.
  64         operator                bool                    (void) const throw() { return !!get();  }
  65
  66 protected:
  67                                         UniqueBase              (T* ptr, D deleter)             : m_data(ptr, deleter) {}
  68                                         UniqueBase              (PtrData<T, D> data)    : m_data(data) {}
  69                                         ~UniqueBase             (void);
  70
  71         void                    reset                   (void);                                 //!< Delete previous pointer, set to null.
  72         PtrData<T, D>   releaseData             (void) throw();                 //!< Relinquish ownership, return pointer data.
  73         void                    assignData              (PtrData<T, D> data);   //!< Set new pointer, delete previous pointer.
  74
  75 private:
  76         PtrData<T, D>   m_data;
  77 };
  78
  79 template <typename T, class D>
  80 UniqueBase<T, D>::~UniqueBase (void)
  81 {
  82         reset();
  83 }
  84
  85 template <typename T, class D>
  86 void UniqueBase<T, D>::reset (void)
  87 {
  88         if (m_data.ptr != DE_NULL)
  89         {
  90                 m_data.deleter(m_data.ptr);
  91                 m_data.ptr = DE_NULL;
  92         }
  93 }
  94
  95 template <typename T, class D>
  96 PtrData<T, D> UniqueBase<T, D>::releaseData (void) throw()
  97 {
  98         PtrData<T, D> data = m_data;
  99         m_data.ptr = DE_NULL;
 100         return data;
 101 }
 102
 103 template <typename T, class D>
 104 void UniqueBase<T, D>::assignData (PtrData<T, D> data)
 105 {
 106         if (data.ptr != m_data.ptr)
 107         {
 108                 reset();
 109                 m_data = data;
 110         }
 111 }
 112
 113 /*--------------------------------------------------------------------*//*!
 114  * \brief Movable unique pointer
 115  *
 116  * A MovePtr is smart pointer that retains sole ownership of a pointer and
 117  * destroys it when it is destroyed (for example when it goes out of scope).
 118  *
 119  * A MovePtr can be copied and assigned to. The pointer ownership is moved to
 120  * the newly constructer or assigned-to MovePtr. Upon assignment to a
 121  * MovePtr, the previously managed pointer is deleted.
 122  *
 123  *//*--------------------------------------------------------------------*/
 124 template<typename T, class Deleter = DefaultDeleter<T> >
 125 class MovePtr : public UniqueBase<T, Deleter>
 126 {
 127 public:
 128                                 MovePtr                         (void)                                                                  : UniqueBase<T, Deleter> (DE_NULL, Deleter()) {}
 129         explicit        MovePtr                         (T* ptr, Deleter deleter = Deleter())   : UniqueBase<T, Deleter> (ptr, deleter) {}
 130                                 MovePtr                         (MovePtr<T, Deleter>& other)                    : UniqueBase<T, Deleter> (other.releaseData()) {}
 131
 132         MovePtr&        operator=                       (MovePtr<T, Deleter>& other);
 133         T*                      release                         (void) throw();
 134         void            clear                           (void) { this->reset(); }
 135
 136         // These implicit by-value conversions to and from a PtrData are used to
 137         // allow copying a MovePtr by value when returning from a function. To
 138         // ensure that the managed pointer gets deleted exactly once, the PtrData
 139         // should only exist as a temporary conversion step between two MovePtrs.
 140                                 MovePtr                         (PtrData<T, Deleter> data) : UniqueBase<T, Deleter> (data) {}
 141         MovePtr&        operator=                       (PtrData<T, Deleter> data);
 142
 143         template<typename U, class Del2>
 144         operator        PtrData<U, Del2>        (void) { return this->releaseData(); }
 145 };
 146
 147 template<typename T, class D>
 148 MovePtr<T, D>& MovePtr<T,D>::operator= (PtrData<T, D> data)
 149 {
 150         this->assignData(data);
 151         return *this;
 152 }
 153
 154 template<typename T, class D>
 155 MovePtr<T, D>& MovePtr<T,D>::operator= (MovePtr<T, D>& other)
 156 {
 157         return (*this = other.releaseData());
 158 }
 159
 160 //! Steal the managed pointer. The caller is responsible for explicitly
 161 //! deleting the returned pointer.
 162 template<typename T, class D>
 163 inline T* MovePtr<T,D>::release (void) throw()
 164 {
 165         return this->releaseData().ptr;
 166 }
 167
 168 //! Construct a MovePtr from a pointer.
 169 template<typename T>
 170 inline MovePtr<T> movePtr (T* ptr)                                      { return MovePtr<T>(ptr); }
 171
 172 //! Allocate and construct an object and return its address as a MovePtr.
 173 template<typename T>
 174 inline MovePtr<T> newMovePtr (void)                                     { return MovePtr<T>(new T()); }
 175 template<typename T, typename P0>
 176 inline MovePtr<T> newMovePtr (P0 p0)                            { return MovePtr<T>(new T(p0)); }
 177 template<typename T, typename P0, typename P1>
 178 inline MovePtr<T> newMovePtr (P0 p0, P1 p1)                     { return MovePtr<T>(new T(p0, p1)); }
 179 template<typename T, typename P0, typename P1, typename P2>
 180 inline MovePtr<T> newMovePtr (P0 p0, P1 p1, P2 p2)      { return MovePtr<T>(new T(p0, p1, p2)); }
 181
 182 /*--------------------------------------------------------------------*//*!
 183  * \brief Unique pointer
 184  *
 185  * UniquePtr is smart pointer that retains sole ownership of a pointer
 186  * and destroys it when UniquePtr is destroyed (for example when UniquePtr
 187  * goes out of scope).
 188  *
 189  * UniquePtr is not copyable or assignable. Pointer ownership can be transferred
 190  * from a UniquePtr only explicitly with the move() member function.
 191  *
 192  * A UniquePtr can be constructed from a MovePtr. In this case it assumes
 193  * ownership of the pointer from the MovePtr. Because a UniquePtr cannot be
 194  * copied, direct initialization syntax must be used, i.e.:
 195  *
 196  *              MovePtr<Foo> createFoo (void);
 197  *              UniquePtr<Foo> fooPtr(createFoo()); // NOT fooPtr = createFoo();
 198  *
 199  *//*--------------------------------------------------------------------*/
 200 template<typename T, class Deleter = DefaultDeleter<T> >
 201 class UniquePtr : public UniqueBase<T, Deleter>
 202 {
 203 public:
 204         explicit                                UniquePtr               (T* ptr, Deleter deleter = Deleter());
 205                                                         UniquePtr               (PtrData<T, Deleter> data);
 206         MovePtr<T, Deleter>             move                    (void);
 207
 208 private:
 209                                                         UniquePtr               (const UniquePtr<T>& other); // Not allowed!
 210         UniquePtr                               operator=               (const UniquePtr<T>& other); // Not allowed!
 211 };
 212
 213 /*--------------------------------------------------------------------*//*!
 214  * \brief Construct unique pointer.
 215  * \param ptr Pointer to be managed.
 216  *
 217  * Pointer ownership is transferred to the UniquePtr.
 218  *//*--------------------------------------------------------------------*/
 219 template<typename T, class Deleter>
 220 inline UniquePtr<T, Deleter>::UniquePtr (T* ptr, Deleter deleter)
 221         : UniqueBase<T, Deleter> (ptr, deleter)
 222 {
 223 }
 224
 225 template<typename T, class Deleter>
 226 inline UniquePtr<T, Deleter>::UniquePtr (PtrData<T, Deleter> data)
 227         : UniqueBase<T, Deleter> (data)
 228 {
 229 }
 230
 231 /*--------------------------------------------------------------------*//*!
 232  * \brief Relinquish ownership of pointer.
 233  *
 234  * This method returns a MovePtr that now owns the pointer. The pointer in
 235  * the UniquePtr is set to null.
 236  *//*--------------------------------------------------------------------*/
 237 template<typename T, class Deleter>
 238 inline MovePtr<T, Deleter> UniquePtr<T, Deleter>::move (void)
 239 {
 240         return MovePtr<T, Deleter>(this->releaseData());
 241 }
 242
 243 } // details
 244
 245 using details::UniquePtr;
 246 using details::MovePtr;
 247 using details::newMovePtr;
 248
 249 } // de
 250
 251 #endif // _DEUNIQUEPTR_HPP