EIC code displayed by LXR master/​include/​boost/​serialization/​detail/​shared_ptr_nmt_132.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-30 09:59:44

 #ifndef BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
 #define BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
 
 //
 //  detail/shared_ptr_nmt.hpp - shared_ptr.hpp without member templates
 //
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
 //  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/shared_ptr.htm for documentation.
 //
 
 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/serialization/throw_exception.hpp>
 #include <boost/detail/atomic_count.hpp>
 
 #ifndef BOOST_NO_AUTO_PTR
 # include <memory>          // for std::auto_ptr
 #endif
 
 #include <algorithm>        // for std::swap
 #include <functional>       // for std::less
 #include <new>              // for std::bad_alloc
 
 namespace boost
 {
 
 template<class T> class shared_ptr
 {
 private:
 
     typedef detail::atomic_count count_type;
 
 public:
 
     typedef T element_type;
     typedef T value_type;
 
     explicit shared_ptr(T * p = 0): px(p)
     {
 #ifndef BOOST_NO_EXCEPTIONS
 
         try  // prevent leak if new throws
         {
             pn = new count_type(1);
         }
         catch(...)
         {
             boost::checked_delete(p);
             throw;
         }
 
 #else
 
         pn = new count_type(1);
 
         if(pn == 0)
         {
             boost::checked_delete(p);
             boost::serialization::throw_exception(std::bad_alloc());
         }
 
 #endif
     }
 
     ~shared_ptr()
     {
         if(--*pn == 0)
         {
             boost::checked_delete(px);
             delete pn;
         }
     }
 
     shared_ptr(shared_ptr const & r): px(r.px)  // never throws
     {
         pn = r.pn;
         ++*pn;
     }
 
     shared_ptr & operator=(shared_ptr const & r)
     {
         shared_ptr(r).swap(*this);
         return *this;
     }
 
 #ifndef BOOST_NO_AUTO_PTR
 
     explicit shared_ptr(std::auto_ptr< T > & r)
     {
         pn = new count_type(1); // may throw
         px = r.release(); // fix: moved here to stop leak if new throws
     }
 
     shared_ptr & operator=(std::auto_ptr< T > & r)
     {
         shared_ptr(r).swap(*this);
         return *this;
     }
 
 #endif
 
     void reset(T * p = 0)
     {
         BOOST_ASSERT(p == 0 || p != px);
         shared_ptr(p).swap(*this);
     }
 
     T & operator*() const  // never throws
     {
         BOOST_ASSERT(px != 0);
         return *px;
     }
 
     T * operator->() const  // never throws
     {
         BOOST_ASSERT(px != 0);
         return px;
     }
 
     T * get() const  // never throws
     {
         return px;
     }
 
     long use_count() const  // never throws
     {
         return *pn;
     }
 
     bool unique() const  // never throws
     {
         return *pn == 1;
     }
 
     void swap(shared_ptr< T > & other)  // never throws
     {
         std::swap(px, other.px);
         std::swap(pn, other.pn);
     }
 
 private:
 
     T * px;            // contained pointer
     count_type * pn;   // ptr to reference counter
 };
 
 template<class T, class U> inline bool operator==(shared_ptr< T > const & a, shared_ptr<U> const & b)
 {
     return a.get() == b.get();
 }
 
 template<class T, class U> inline bool operator!=(shared_ptr< T > const & a, shared_ptr<U> const & b)
 {
     return a.get() != b.get();
 }
 
 template<class T> inline bool operator<(shared_ptr< T > const & a, shared_ptr< T > const & b)
 {
     return std::less<T*>()(a.get(), b.get());
 }
 
 template<class T> void swap(shared_ptr< T > & a, shared_ptr< T > & b)
 {
     a.swap(b);
 }
 
 // get_pointer() enables boost::mem_fn to recognize shared_ptr
 
 template<class T> inline T * get_pointer(shared_ptr< T > const & p)
 {
     return p.get();
 }
 
 } // namespace boost
 
 #endif  // #ifndef BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED

This page was automatically generated by the 2.3.7 LXR engine. The LXR team