stc/exp/ml_stc_linux_make_v1.0/include/boost/smart_ptr/detail/shared_ptr_nmt.hpp

   1 #ifndef BOOST_SMART_PTR_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED\r
   2 #define BOOST_SMART_PTR_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED\r
   3 \r
   4 //\r
   5 //  detail/shared_ptr_nmt.hpp - shared_ptr.hpp without member templates\r
   6 //\r
   7 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.\r
   8 //  Copyright (c) 2001, 2002 Peter Dimov\r
   9 //\r
  10 //  Distributed under the Boost Software License, Version 1.0. (See\r
  11 //  accompanying file LICENSE_1_0.txt or copy at\r
  12 //  http://www.boost.org/LICENSE_1_0.txt)\r
  13 //\r
  14 //  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.\r
  15 //\r
  16 \r
  17 #include <boost/assert.hpp>\r
  18 #include <boost/checked_delete.hpp>\r
  19 #include <boost/throw_exception.hpp>\r
  20 #include <boost/smart_ptr/detail/atomic_count.hpp>\r
  21 \r
  22 #ifndef BOOST_NO_AUTO_PTR\r
  23 # include <memory>          // for std::auto_ptr\r
  24 #endif\r
  25 \r
  26 #include <algorithm>        // for std::swap\r
  27 #include <functional>       // for std::less\r
  28 #include <new>              // for std::bad_alloc\r
  29 \r
  30 namespace boost\r
  31 {\r
  32 \r
  33 template<class T> class shared_ptr\r
  34 {\r
  35 private:\r
  36 \r
  37     typedef detail::atomic_count count_type;\r
  38 \r
  39 public:\r
  40 \r
  41     typedef T element_type;\r
  42     typedef T value_type;\r
  43 \r
  44     explicit shared_ptr(T * p = 0): px(p)\r
  45     {\r
  46 #ifndef BOOST_NO_EXCEPTIONS\r
  47 \r
  48         try  // prevent leak if new throws\r
  49         {\r
  50             pn = new count_type(1);\r
  51         }\r
  52         catch(...)\r
  53         {\r
  54             boost::checked_delete(p);\r
  55             throw;\r
  56         }\r
  57 \r
  58 #else\r
  59 \r
  60         pn = new count_type(1);\r
  61 \r
  62         if(pn == 0)\r
  63         {\r
  64             boost::checked_delete(p);\r
  65             boost::throw_exception(std::bad_alloc());\r
  66         }\r
  67 \r
  68 #endif\r
  69     }\r
  70 \r
  71     ~shared_ptr()\r
  72     {\r
  73         if(--*pn == 0)\r
  74         {\r
  75             boost::checked_delete(px);\r
  76             delete pn;\r
  77         }\r
  78     }\r
  79 \r
  80     shared_ptr(shared_ptr const & r): px(r.px)  // never throws\r
  81     {\r
  82         pn = r.pn;\r
  83         ++*pn;\r
  84     }\r
  85 \r
  86     shared_ptr & operator=(shared_ptr const & r)\r
  87     {\r
  88         shared_ptr(r).swap(*this);\r
  89         return *this;\r
  90     }\r
  91 \r
  92 #ifndef BOOST_NO_AUTO_PTR\r
  93 \r
  94     explicit shared_ptr(std::auto_ptr<T> & r)\r
  95     { \r
  96         pn = new count_type(1); // may throw\r
  97         px = r.release(); // fix: moved here to stop leak if new throws\r
  98     } \r
  99 \r
 100     shared_ptr & operator=(std::auto_ptr<T> & r)\r
 101     {\r
 102         shared_ptr(r).swap(*this);\r
 103         return *this;\r
 104     }\r
 105 \r
 106 #endif\r
 107 \r
 108     void reset(T * p = 0)\r
 109     {\r
 110         BOOST_ASSERT(p == 0 || p != px);\r
 111         shared_ptr(p).swap(*this);\r
 112     }\r
 113 \r
 114     T & operator*() const  // never throws\r
 115     {\r
 116         BOOST_ASSERT(px != 0);\r
 117         return *px;\r
 118     }\r
 119 \r
 120     T * operator->() const  // never throws\r
 121     {\r
 122         BOOST_ASSERT(px != 0);\r
 123         return px;\r
 124     }\r
 125 \r
 126     T * get() const  // never throws\r
 127     {\r
 128         return px;\r
 129     }\r
 130 \r
 131     long use_count() const  // never throws\r
 132     {\r
 133         return *pn;\r
 134     }\r
 135 \r
 136     bool unique() const  // never throws\r
 137     {\r
 138         return *pn == 1;\r
 139     }\r
 140     \r
 141     void swap(shared_ptr<T> & other)  // never throws\r
 142     {\r
 143         std::swap(px, other.px);\r
 144         std::swap(pn, other.pn);\r
 145     }\r
 146 \r
 147 private:\r
 148 \r
 149     T * px;            // contained pointer\r
 150     count_type * pn;   // ptr to reference counter\r
 151 };\r
 152 \r
 153 template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)\r
 154 {\r
 155     return a.get() == b.get();\r
 156 }\r
 157 \r
 158 template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)\r
 159 {\r
 160     return a.get() != b.get();\r
 161 }\r
 162 \r
 163 template<class T> inline bool operator<(shared_ptr<T> const & a, shared_ptr<T> const & b)\r
 164 {\r
 165     return std::less<T*>()(a.get(), b.get());\r
 166 }\r
 167 \r
 168 template<class T> void swap(shared_ptr<T> & a, shared_ptr<T> & b)\r
 169 {\r
 170     a.swap(b);\r
 171 }\r
 172 \r
 173 // get_pointer() enables boost::mem_fn to recognize shared_ptr\r
 174 \r
 175 template<class T> inline T * get_pointer(shared_ptr<T> const & p)\r
 176 {\r
 177     return p.get();\r
 178 }\r
 179 \r
 180 } // namespace boost\r
 181 \r
 182 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED\r