| #ifndef BOOST_SMART_PTR_SHARED_ARRAY_HPP_INCLUDED |
| #define BOOST_SMART_PTR_SHARED_ARRAY_HPP_INCLUDED |
| |
| // |
| // shared_array.hpp |
| // |
| // (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_array.htm for documentation. |
| // |
| |
| #include <boost/config.hpp> // for broken compiler workarounds |
| |
| #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) |
| #include <boost/smart_ptr/detail/shared_array_nmt.hpp> |
| #else |
| |
| #include <memory> // TR1 cyclic inclusion fix |
| |
| #include <boost/assert.hpp> |
| #include <boost/checked_delete.hpp> |
| |
| #include <boost/smart_ptr/detail/shared_count.hpp> |
| #include <boost/detail/workaround.hpp> |
| |
| #include <cstddef> // for std::ptrdiff_t |
| #include <algorithm> // for std::swap |
| #include <functional> // for std::less |
| |
| namespace boost |
| { |
| |
| // |
| // shared_array |
| // |
| // shared_array extends shared_ptr to arrays. |
| // The array pointed to is deleted when the last shared_array pointing to it |
| // is destroyed or reset. |
| // |
| |
| template<class T> class shared_array |
| { |
| private: |
| |
| // Borland 5.5.1 specific workarounds |
| typedef checked_array_deleter<T> deleter; |
| typedef shared_array<T> this_type; |
| |
| public: |
| |
| typedef T element_type; |
| |
| explicit shared_array(T * p = 0): px(p), pn(p, deleter()) |
| { |
| } |
| |
| // |
| // Requirements: D's copy constructor must not throw |
| // |
| // shared_array will release p by calling d(p) |
| // |
| |
| template<class D> shared_array(T * p, D d): px(p), pn(p, d) |
| { |
| } |
| |
| // generated copy constructor, assignment, destructor are fine |
| |
| void reset(T * p = 0) |
| { |
| BOOST_ASSERT(p == 0 || p != px); |
| this_type(p).swap(*this); |
| } |
| |
| template <class D> void reset(T * p, D d) |
| { |
| this_type(p, d).swap(*this); |
| } |
| |
| T & operator[] (std::ptrdiff_t i) const // never throws |
| { |
| BOOST_ASSERT(px != 0); |
| BOOST_ASSERT(i >= 0); |
| return px[i]; |
| } |
| |
| T * get() const // never throws |
| { |
| return px; |
| } |
| |
| // implicit conversion to "bool" |
| #include <boost/smart_ptr/detail/operator_bool.hpp> |
| |
| bool unique() const // never throws |
| { |
| return pn.unique(); |
| } |
| |
| long use_count() const // never throws |
| { |
| return pn.use_count(); |
| } |
| |
| void swap(shared_array<T> & other) // never throws |
| { |
| std::swap(px, other.px); |
| pn.swap(other.pn); |
| } |
| |
| private: |
| |
| T * px; // contained pointer |
| detail::shared_count pn; // reference counter |
| |
| }; // shared_array |
| |
| template<class T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) // never throws |
| { |
| return a.get() == b.get(); |
| } |
| |
| template<class T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) // never throws |
| { |
| return a.get() != b.get(); |
| } |
| |
| template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) // never throws |
| { |
| return std::less<T*>()(a.get(), b.get()); |
| } |
| |
| template<class T> void swap(shared_array<T> & a, shared_array<T> & b) // never throws |
| { |
| a.swap(b); |
| } |
| |
| } // namespace boost |
| |
| #endif // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) |
| |
| #endif // #ifndef BOOST_SMART_PTR_SHARED_ARRAY_HPP_INCLUDED |