FCL/sf/os/ossrv: comparison ossrv_pub/boost_apis/boost/intrusive

equal deleted inserted replaced

--1:000000000000
+:e4d67989cc36
+#ifndef BOOST_INTRUSIVE_PTR_HPP_INCLUDED
+#define BOOST_INTRUSIVE_PTR_HPP_INCLUDED
+//
+//  intrusive_ptr.hpp
+//
+//  Copyright (c) 2001, 2002 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+//  See http://www.boost.org/libs/smart_ptr/intrusive_ptr.html for documentation.
+//
+#include <boost/config.hpp>
+#ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
+# pragma warning(push)
+# pragma warning(disable:4284) // odd return type for operator->
+#endif
+#include <boost/assert.hpp>
+#include <boost/detail/workaround.hpp>
+#include <functional>           // for std::less
+#include <iosfwd>               // for std::basic_ostream
+namespace boost
+{
+//
+//  intrusive_ptr
+//
+//  A smart pointer that uses intrusive reference counting.
+//
+//  Relies on unqualified calls to
+//
+//      void intrusive_ptr_add_ref(T * p);
+//      void intrusive_ptr_release(T * p);
+//
+//          (p != 0)
+//
+//  The object is responsible for destroying itself.
+//
+template<class T> class intrusive_ptr
+{
+private:
+typedef intrusive_ptr this_type;
+public:
+typedef T element_type;
+intrusive_ptr(): p_(0)
+{
+}
+intrusive_ptr(T * p, bool add_ref = true): p_(p)
+{
+if(p_ != 0 && add_ref) intrusive_ptr_add_ref(p_);
+}
+#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+template<class U> intrusive_ptr(intrusive_ptr<U> const & rhs): p_(rhs.get())
+{
+if(p_ != 0) intrusive_ptr_add_ref(p_);
+}
+#endif
+intrusive_ptr(intrusive_ptr const & rhs): p_(rhs.p_)
+{
+if(p_ != 0) intrusive_ptr_add_ref(p_);
+}
+~intrusive_ptr()
+{
+if(p_ != 0) intrusive_ptr_release(p_);
+}
+#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+template<class U> intrusive_ptr & operator=(intrusive_ptr<U> const & rhs)
+{
+this_type(rhs).swap(*this);
+return *this;
+}
+#endif
+intrusive_ptr & operator=(intrusive_ptr const & rhs)
+{
+this_type(rhs).swap(*this);
+return *this;
+}
+intrusive_ptr & operator=(T * rhs)
+{
+this_type(rhs).swap(*this);
+return *this;
+}
+T * get() const
+{
+return p_;
+}
+T & operator*() const
+{
+return *p_;
+}
+T * operator->() const
+{
+return p_;
+}
+#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
+operator bool () const
+{
+return p_ != 0;
+}
+#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+typedef T * (this_type::*unspecified_bool_type)() const;
+operator unspecified_bool_type() const // never throws
+{
+return p_ == 0? 0: &this_type::get;
+}
+#else
+typedef T * this_type::*unspecified_bool_type;
+operator unspecified_bool_type () const
+{
+return p_ == 0? 0: &this_type::p_;
+}
+#endif
+// operator! is a Borland-specific workaround
+bool operator! () const
+{
+return p_ == 0;
+}
+void swap(intrusive_ptr & rhs)
+{
+T * tmp = p_;
+p_ = rhs.p_;
+rhs.p_ = tmp;
+}
+private:
+T * p_;
+};
+template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b)
+{
+return a.get() == b.get();
+}
+template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b)
+{
+return a.get() != b.get();
+}
+template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, U * b)
+{
+return a.get() == b;
+}
+template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, U * b)
+{
+return a.get() != b;
+}
+template<class T, class U> inline bool operator==(T * a, intrusive_ptr<U> const & b)
+{
+return a == b.get();
+}
+template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const & b)
+{
+return a != b.get();
+}
+#if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
+// Resolve the ambiguity between our op!= and the one in rel_ops
+template<class T> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
+{
+return a.get() != b.get();
+}
+#endif
+template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
+{
+return std::less<T *>()(a.get(), b.get());
+}
+template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs)
+{
+lhs.swap(rhs);
+}
+// mem_fn support
+template<class T> T * get_pointer(intrusive_ptr<T> const & p)
+{
+return p.get();
+}
+template<class T, class U> intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const & p)
+{
+return static_cast<T *>(p.get());
+}
+template<class T, class U> intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U> const & p)
+{
+return const_cast<T *>(p.get());
+}
+template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> const & p)
+{
+return dynamic_cast<T *>(p.get());
+}
+// operator<<
+#if defined(__GNUC__) &&  (__GNUC__ < 3)
+template<class Y> std::ostream & operator<< (std::ostream & os, intrusive_ptr<Y> const & p)
+{
+os << p.get();
+return os;
+}
+#else
+// in STLport's no-iostreams mode no iostream symbols can be used
+#ifndef _STLP_NO_IOSTREAMS
+# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300 && __SGI_STL_PORT)
+// MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL
+using std::basic_ostream;
+template<class E, class T, class Y> basic_ostream<E, T> & operator<< (basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)
+# else
+template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)
+# endif
+{
+os << p.get();
+return os;
+}
+#endif // _STLP_NO_IOSTREAMS
+#endif // __GNUC__ < 3
+} // namespace boost
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+#endif  // #ifndef BOOST_INTRUSIVE_PTR_HPP_INCLUDED