l4/pkg/cxx/lib/tl/include/unique_ptr

   1 #pragma once
   2
   3 #include "type_traits"
   4
   5 namespace cxx
   6 {
   7
   8 template< typename T >
   9 struct default_delete
  10 {
  11   default_delete() {}
  12
  13   template< typename U >
  14   default_delete(default_delete<U> const &) {}
  15
  16   void operator () (T *p) const
  17   { delete p; }
  18 };
  19
  20 template< typename T >
  21 struct default_delete<T[]>
  22 {
  23   default_delete() {}
  24
  25   void operator () (T *p)
  26   { delete [] p; }
  27 };
  28
  29 template< typename T, typename T_Del = default_delete<T> >
  30 class unique_ptr
  31 {
  32 private:
  33   struct _unspec;
  34   typedef _unspec* _unspec_ptr_type;
  35
  36 public:
  37   typedef typename cxx::remove_extent<T>::type element_type;
  38   typedef element_type *pointer;
  39   typedef element_type &reference;
  40   typedef T_Del deleter_type;
  41
  42   unique_ptr() : _ptr(pointer()) {}
  43
  44   explicit unique_ptr(pointer p) : _ptr(p) {}
  45
  46   unique_ptr(unique_ptr &&o) : _ptr(o.release()) {}
  47
  48   ~unique_ptr() { reset(); }
  49
  50   unique_ptr &operator = (unique_ptr &&o)
  51   {
  52     reset(o.release());
  53     return *this;
  54   }
  55
  56   unique_ptr &operator = (_unspec_ptr_type)
  57   {
  58     reset();
  59     return *this;
  60   }
  61
  62   element_type &operator * () const { return *get(); }
  63   pointer operator -> () const { return get(); }
  64
  65   pointer get() const { return _ptr; }
  66
  67   operator _unspec_ptr_type () const
  68   { return reinterpret_cast<_unspec_ptr_type>(get()); }
  69
  70   pointer release()
  71   {
  72     pointer r = _ptr;
  73     _ptr = 0;
  74     return r;
  75   }
  76
  77   void reset(pointer p = pointer())
  78   {
  79     if (p != get())
  80       {
  81         deleter_type()(get());
  82         _ptr = p;
  83       }
  84   }
  85
  86   typename cxx::enable_if<cxx::is_array<T>::value, reference>::type
  87   operator [] (unsigned long idx) const
  88   { return _ptr[idx]; }
  89
  90
  91   unique_ptr(unique_ptr const &) = delete;
  92   unique_ptr &operator = (unique_ptr const &) = delete;
  93
  94
  95 private:
  96   pointer _ptr;
  97 };
  98
  99 template< typename T >
 100 unique_ptr<T>
 101 make_unique_ptr(T *p)
 102 { return unique_ptr<T>(p); }
 103
 104 }