test: epoc32/include/stdapis/boost/intrusive

     1 #ifndef BOOST_INTRUSIVE_PTR_HPP_INCLUDED

     2 #define BOOST_INTRUSIVE_PTR_HPP_INCLUDED

     4 //

     5 //  intrusive_ptr.hpp

     6 //

     7 //  Copyright (c) 2001, 2002 Peter Dimov

     8 //

     9 // Distributed under the Boost Software License, Version 1.0. (See

    10 // accompanying file LICENSE_1_0.txt or copy at

    11 // http://www.boost.org/LICENSE_1_0.txt)

    12 //

    13 //  See http://www.boost.org/libs/smart_ptr/intrusive_ptr.html for documentation.

    14 //

    16 #include <boost/config.hpp>

    18 #ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash

    19 # pragma warning(push)

    20 # pragma warning(disable:4284) // odd return type for operator->

    21 #endif

    23 #include <boost/assert.hpp>

    24 #include <boost/detail/workaround.hpp>

    26 #include <functional>           // for std::less

    27 #include <iosfwd>               // for std::basic_ostream

    30 namespace boost

    31 {

    33 //

    34 //  intrusive_ptr

    35 //

    36 //  A smart pointer that uses intrusive reference counting.

    37 //

    38 //  Relies on unqualified calls to

    39 //

    40 //      void intrusive_ptr_add_ref(T * p);

    41 //      void intrusive_ptr_release(T * p);

    42 //

    43 //          (p != 0)

    44 //

    45 //  The object is responsible for destroying itself.

    46 //

    48 template<class T> class intrusive_ptr

    49 {

    50 private:

    52     typedef intrusive_ptr this_type;

    54 public:

    56     typedef T element_type;

    58     intrusive_ptr(): p_(0)

    59     {

    60     }

    62     intrusive_ptr(T * p, bool add_ref = true): p_(p)

    63     {

    64         if(p_ != 0 && add_ref) intrusive_ptr_add_ref(p_);

    65     }

    67 #if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)

    69     template<class U> intrusive_ptr(intrusive_ptr<U> const & rhs): p_(rhs.get())

    70     {

    71         if(p_ != 0) intrusive_ptr_add_ref(p_);

    72     }

    74 #endif

    76     intrusive_ptr(intrusive_ptr const & rhs): p_(rhs.p_)

    77     {

    78         if(p_ != 0) intrusive_ptr_add_ref(p_);

    79     }

    81     ~intrusive_ptr()

    82     {

    83         if(p_ != 0) intrusive_ptr_release(p_);

    84     }

    86 #if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)

    88     template<class U> intrusive_ptr & operator=(intrusive_ptr<U> const & rhs)

    89     {

    90         this_type(rhs).swap(*this);

    91         return *this;

    92     }

    94 #endif

    96     intrusive_ptr & operator=(intrusive_ptr const & rhs)

    97     {

    98         this_type(rhs).swap(*this);

    99         return *this;

   100     }

   102     intrusive_ptr & operator=(T * rhs)

   103     {

   104         this_type(rhs).swap(*this);

   105         return *this;

   106     }

   108     T * get() const

   109     {

   110         return p_;

   111     }

   113     T & operator*() const

   114     {

   115         return *p_;

   116     }

   118     T * operator->() const

   119     {

   120         return p_;

   121     }

   123 #if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)

   125     operator bool () const

   126     {

   127         return p_ != 0;

   128     }

   130 #elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))

   131     typedef T * (this_type::*unspecified_bool_type)() const;

   133     operator unspecified_bool_type() const // never throws

   134     {

   135         return p_ == 0? 0: &this_type::get;

   136     }

   138 #else

   140     typedef T * this_type::*unspecified_bool_type;

   142     operator unspecified_bool_type () const

   143     {

   144         return p_ == 0? 0: &this_type::p_;

   145     }

   147 #endif

   149     // operator! is a Borland-specific workaround

   150     bool operator! () const

   151     {

   152         return p_ == 0;

   153     }

   155     void swap(intrusive_ptr & rhs)

   156     {

   157         T * tmp = p_;

   158         p_ = rhs.p_;

   159         rhs.p_ = tmp;

   160     }

   162 private:

   164     T * p_;

   165 };

   167 template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b)

   168 {

   169     return a.get() == b.get();

   170 }

   172 template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b)

   173 {

   174     return a.get() != b.get();

   175 }

   177 template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, U * b)

   178 {

   179     return a.get() == b;

   180 }

   182 template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, U * b)

   183 {

   184     return a.get() != b;

   185 }

   187 template<class T, class U> inline bool operator==(T * a, intrusive_ptr<U> const & b)

   188 {

   189     return a == b.get();

   190 }

   192 template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const & b)

   193 {

   194     return a != b.get();

   195 }

   197 #if __GNUC__ == 2 && __GNUC_MINOR__ <= 96

   199 // Resolve the ambiguity between our op!= and the one in rel_ops

   201 template<class T> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)

   202 {

   203     return a.get() != b.get();

   204 }

   206 #endif

   208 template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)

   209 {

   210     return std::less<T *>()(a.get(), b.get());

   211 }

   213 template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs)

   214 {

   215     lhs.swap(rhs);

   216 }

   218 // mem_fn support

   220 template<class T> T * get_pointer(intrusive_ptr<T> const & p)

   221 {

   222     return p.get();

   223 }

   225 template<class T, class U> intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const & p)

   226 {

   227     return static_cast<T *>(p.get());

   228 }

   230 template<class T, class U> intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U> const & p)

   231 {

   232     return const_cast<T *>(p.get());

   233 }

   235 template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> const & p)

   236 {

   237     return dynamic_cast<T *>(p.get());

   238 }

   240 // operator<<

   242 #if defined(__GNUC__) &&  (__GNUC__ < 3)

   244 template<class Y> std::ostream & operator<< (std::ostream & os, intrusive_ptr<Y> const & p)

   245 {

   246     os << p.get();

   247     return os;

   248 }

   250 #else

   252 // in STLport's no-iostreams mode no iostream symbols can be used

   253 #ifndef _STLP_NO_IOSTREAMS

   255 # if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300 && __SGI_STL_PORT)

   256 // MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL

   257 using std::basic_ostream;

   258 template<class E, class T, class Y> basic_ostream<E, T> & operator<< (basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)

   259 # else

   260 template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)

   261 # endif

   262 {

   263     os << p.get();

   264     return os;

   265 }

   267 #endif // _STLP_NO_IOSTREAMS

   269 #endif // __GNUC__ < 3

   271 } // namespace boost

   273 #ifdef BOOST_MSVC

   274 # pragma warning(pop)

   275 #endif

   277 #endif  // #ifndef BOOST_INTRUSIVE_PTR_HPP_INCLUDED

author	William Roberts <williamr@symbian.org>
	Wed, 31 Mar 2010 12:27:01 +0100
branch	Symbian2
changeset 3	e1b950c65cb4
permissions	-rw-r--r--