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

   1 #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED\r
   2 #define BOOST_SMART_PTR_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED\r
   3 \r
   4 // MS compatible compilers support #pragma once\r
   5 \r
   6 #if defined(_MSC_VER) && (_MSC_VER >= 1020)\r
   7 # pragma once\r
   8 #endif\r
   9 \r
  10 //\r
  11 //  detail/sp_counted_impl.hpp\r
  12 //\r
  13 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.\r
  14 //  Copyright 2004-2005 Peter Dimov\r
  15 //\r
  16 // Distributed under the Boost Software License, Version 1.0. (See\r
  17 // accompanying file LICENSE_1_0.txt or copy at\r
  18 // http://www.boost.org/LICENSE_1_0.txt)\r
  19 //\r
  20 \r
  21 #include <boost/config.hpp>\r
  22 \r
  23 #if defined(BOOST_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR)\r
  24 # error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible.\r
  25 #endif\r
  26 \r
  27 #include <boost/checked_delete.hpp>\r
  28 #include <boost/smart_ptr/detail/sp_counted_base.hpp>\r
  29 \r
  30 #if defined(BOOST_SP_USE_QUICK_ALLOCATOR)\r
  31 #include <boost/smart_ptr/detail/quick_allocator.hpp>\r
  32 #endif\r
  33 \r
  34 #if defined(BOOST_SP_USE_STD_ALLOCATOR)\r
  35 #include <memory>           // std::allocator\r
  36 #endif\r
  37 \r
  38 #include <cstddef>          // std::size_t\r
  39 \r
  40 namespace boost\r
  41 {\r
  42 \r
  43 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\r
  44 \r
  45 void sp_scalar_constructor_hook( void * px, std::size_t size, void * pn );\r
  46 void sp_scalar_destructor_hook( void * px, std::size_t size, void * pn );\r
  47 \r
  48 #endif\r
  49 \r
  50 namespace detail\r
  51 {\r
  52 \r
  53 template<class X> class sp_counted_impl_p: public sp_counted_base\r
  54 {\r
  55 private:\r
  56 \r
  57     X * px_;\r
  58 \r
  59     sp_counted_impl_p( sp_counted_impl_p const & );\r
  60     sp_counted_impl_p & operator= ( sp_counted_impl_p const & );\r
  61 \r
  62     typedef sp_counted_impl_p<X> this_type;\r
  63 \r
  64 public:\r
  65 \r
  66     explicit sp_counted_impl_p( X * px ): px_( px )\r
  67     {\r
  68 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\r
  69         boost::sp_scalar_constructor_hook( px, sizeof(X), this );\r
  70 #endif\r
  71     }\r
  72 \r
  73     virtual void dispose() // nothrow\r
  74     {\r
  75 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)\r
  76         boost::sp_scalar_destructor_hook( px_, sizeof(X), this );\r
  77 #endif\r
  78         boost::checked_delete( px_ );\r
  79     }\r
  80 \r
  81     virtual void * get_deleter( detail::sp_typeinfo const & )\r
  82     {\r
  83         return 0;\r
  84     }\r
  85 \r
  86 #if defined(BOOST_SP_USE_STD_ALLOCATOR)\r
  87 \r
  88     void * operator new( std::size_t )\r
  89     {\r
  90         return std::allocator<this_type>().allocate( 1, static_cast<this_type *>(0) );\r
  91     }\r
  92 \r
  93     void operator delete( void * p )\r
  94     {\r
  95         std::allocator<this_type>().deallocate( static_cast<this_type *>(p), 1 );\r
  96     }\r
  97 \r
  98 #endif\r
  99 \r
 100 #if defined(BOOST_SP_USE_QUICK_ALLOCATOR)\r
 101 \r
 102     void * operator new( std::size_t )\r
 103     {\r
 104         return quick_allocator<this_type>::alloc();\r
 105     }\r
 106 \r
 107     void operator delete( void * p )\r
 108     {\r
 109         quick_allocator<this_type>::dealloc( p );\r
 110     }\r
 111 \r
 112 #endif\r
 113 };\r
 114 \r
 115 //\r
 116 // Borland's Codeguard trips up over the -Vx- option here:\r
 117 //\r
 118 #ifdef __CODEGUARD__\r
 119 # pragma option push -Vx-\r
 120 #endif\r
 121 \r
 122 template<class P, class D> class sp_counted_impl_pd: public sp_counted_base\r
 123 {\r
 124 private:\r
 125 \r
 126     P ptr; // copy constructor must not throw\r
 127     D del; // copy constructor must not throw\r
 128 \r
 129     sp_counted_impl_pd( sp_counted_impl_pd const & );\r
 130     sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );\r
 131 \r
 132     typedef sp_counted_impl_pd<P, D> this_type;\r
 133 \r
 134 public:\r
 135 \r
 136     // pre: d(p) must not throw\r
 137 \r
 138     sp_counted_impl_pd( P p, D d ): ptr(p), del(d)\r
 139     {\r
 140     }\r
 141 \r
 142     virtual void dispose() // nothrow\r
 143     {\r
 144         del( ptr );\r
 145     }\r
 146 \r
 147     virtual void * get_deleter( detail::sp_typeinfo const & ti )\r
 148     {\r
 149         return ti == BOOST_SP_TYPEID(D)? &reinterpret_cast<char&>( del ): 0;\r
 150     }\r
 151 \r
 152 #if defined(BOOST_SP_USE_STD_ALLOCATOR)\r
 153 \r
 154     void * operator new( std::size_t )\r
 155     {\r
 156         return std::allocator<this_type>().allocate( 1, static_cast<this_type *>(0) );\r
 157     }\r
 158 \r
 159     void operator delete( void * p )\r
 160     {\r
 161         std::allocator<this_type>().deallocate( static_cast<this_type *>(p), 1 );\r
 162     }\r
 163 \r
 164 #endif\r
 165 \r
 166 #if defined(BOOST_SP_USE_QUICK_ALLOCATOR)\r
 167 \r
 168     void * operator new( std::size_t )\r
 169     {\r
 170         return quick_allocator<this_type>::alloc();\r
 171     }\r
 172 \r
 173     void operator delete( void * p )\r
 174     {\r
 175         quick_allocator<this_type>::dealloc( p );\r
 176     }\r
 177 \r
 178 #endif\r
 179 };\r
 180 \r
 181 template<class P, class D, class A> class sp_counted_impl_pda: public sp_counted_base\r
 182 {\r
 183 private:\r
 184 \r
 185     P p_; // copy constructor must not throw\r
 186     D d_; // copy constructor must not throw\r
 187     A a_; // copy constructor must not throw\r
 188 \r
 189     sp_counted_impl_pda( sp_counted_impl_pda const & );\r
 190     sp_counted_impl_pda & operator= ( sp_counted_impl_pda const & );\r
 191 \r
 192     typedef sp_counted_impl_pda<P, D, A> this_type;\r
 193 \r
 194 public:\r
 195 \r
 196     // pre: d( p ) must not throw\r
 197 \r
 198     sp_counted_impl_pda( P p, D d, A a ): p_( p ), d_( d ), a_( a )\r
 199     {\r
 200     }\r
 201 \r
 202     virtual void dispose() // nothrow\r
 203     {\r
 204         d_( p_ );\r
 205     }\r
 206 \r
 207     virtual void destroy() // nothrow\r
 208     {\r
 209         typedef typename A::template rebind< this_type >::other A2;\r
 210 \r
 211         A2 a2( a_ );\r
 212 \r
 213         this->~this_type();\r
 214         a2.deallocate( this, 1 );\r
 215     }\r
 216 \r
 217     virtual void * get_deleter( detail::sp_typeinfo const & ti )\r
 218     {\r
 219         return ti == BOOST_SP_TYPEID( D )? &reinterpret_cast<char&>( d_ ): 0;\r
 220     }\r
 221 };\r
 222 \r
 223 #ifdef __CODEGUARD__\r
 224 # pragma option pop\r
 225 #endif\r
 226 \r
 227 } // namespace detail\r
 228 \r
 229 } // namespace boost\r
 230 \r
 231 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED\r