Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r55775 - sandbox-branches/intrusive_fix_SunCC/libs/intrusive/test
From: C.Hite_at_[hidden]
Date: 2009-08-25 08:38:20


Author: chris_hite
Date: 2009-08-25 08:38:19 EDT (Tue, 25 Aug 2009)
New Revision: 55775
URL: http://svn.boost.org/trac/boost/changeset/55775

Log:
removed explicit from smart_ptr ctor
Text files modified:
   sandbox-branches/intrusive_fix_SunCC/libs/intrusive/test/smart_ptr.hpp | 104 ++++++++++++++++++++--------------------
   1 files changed, 52 insertions(+), 52 deletions(-)

Modified: sandbox-branches/intrusive_fix_SunCC/libs/intrusive/test/smart_ptr.hpp
==============================================================================
--- sandbox-branches/intrusive_fix_SunCC/libs/intrusive/test/smart_ptr.hpp (original)
+++ sandbox-branches/intrusive_fix_SunCC/libs/intrusive/test/smart_ptr.hpp 2009-08-25 08:38:19 EDT (Tue, 25 Aug 2009)
@@ -34,9 +34,9 @@
 struct empty_type{};
 
 template<class T>
-struct random_it
-: public boost::iterator<std::random_access_iterator_tag,
- T, std::ptrdiff_t, T*, T&>
+struct random_it
+: public boost::iterator<std::random_access_iterator_tag,
+ T, std::ptrdiff_t, T*, T&>
 {
    typedef const T* const_pointer;
    typedef const T& const_reference;
@@ -108,25 +108,25 @@
    public: //Public Functions
 
    //!Constructor from raw pointer (allows "0" pointer conversion). Never throws.
- explicit smart_ptr(pointer ptr = 0)
+ smart_ptr(pointer ptr = 0)
       : m_ptr(ptr)
    {}
 
    //!Constructor from other pointer. Never throws.
    template <class T>
- smart_ptr(T *ptr)
+ smart_ptr(T *ptr)
       : m_ptr(ptr)
    {}
 
- //!Constructor from other smart_ptr
+ //!Constructor from other smart_ptr
    smart_ptr(const smart_ptr& ptr)
       : m_ptr(ptr.m_ptr)
    {}
 
- //!Constructor from other smart_ptr. If pointers of pointee types are
+ //!Constructor from other smart_ptr. If pointers of pointee types are
    //!convertible, offset_ptrs will be convertibles. Never throws.
    template<class T2>
- smart_ptr(const smart_ptr<T2> &ptr)
+ smart_ptr(const smart_ptr<T2> &ptr)
       : m_ptr(ptr.m_ptr)
    {}
 
@@ -159,16 +159,16 @@
    { return m_ptr; }
 
    //!Pointer-like -> operator. It can return 0 pointer. Never throws.
- pointer operator->() const
+ pointer operator->() const
    { return this->get(); }
 
- //!Dereferencing operator, if it is a null smart_ptr behavior
+ //!Dereferencing operator, if it is a null smart_ptr behavior
    //! is undefined. Never throws.
- reference operator* () const
+ reference operator* () const
    { return *(this->get()); }
 
    //!Indexing operator. Never throws.
- reference operator[](std::ptrdiff_t idx) const
+ reference operator[](std::ptrdiff_t idx) const
    { return this->get()[idx]; }
 
    //!Assignment from pointer (saves extra conversion). Never throws.
@@ -179,18 +179,18 @@
    smart_ptr& operator= (const smart_ptr & pt)
    { m_ptr = pt.m_ptr; return *this; }
 
- //!Assignment from related smart_ptr. If pointers of pointee types
+ //!Assignment from related smart_ptr. If pointers of pointee types
    //! are assignable, offset_ptrs will be assignable. Never throws.
    template <class T2>
    smart_ptr& operator= (const smart_ptr<T2> & pt)
    { m_ptr = pt.m_ptr; return *this; }
-
+
    //!smart_ptr + std::ptrdiff_t. Never throws.
- smart_ptr operator+ (std::ptrdiff_t offset) const
+ smart_ptr operator+ (std::ptrdiff_t offset) const
    { return smart_ptr(this->get()+offset); }
 
    //!smart_ptr - std::ptrdiff_t. Never throws.
- smart_ptr operator- (std::ptrdiff_t offset) const
+ smart_ptr operator- (std::ptrdiff_t offset) const
    { return smart_ptr(this->get()-offset); }
 
    //!smart_ptr += std::ptrdiff_t. Never throws.
@@ -202,7 +202,7 @@
    { m_ptr -= offset; return *this; }
 
    //!++smart_ptr. Never throws.
- smart_ptr& operator++ (void)
+ smart_ptr& operator++ (void)
    { ++m_ptr; return *this; }
 
    //!smart_ptr++. Never throws.
@@ -210,7 +210,7 @@
    { smart_ptr temp(*this); ++*this; return temp; }
 
    //!--smart_ptr. Never throws.
- smart_ptr& operator-- (void)
+ smart_ptr& operator-- (void)
    { --m_ptr; return *this; }
 
    //!smart_ptr--. Never throws.
@@ -218,16 +218,16 @@
    { smart_ptr temp(*this); --*this; return temp; }
 
    //!safe bool conversion operator. Never throws.
- operator unspecified_bool_type() const
+ operator unspecified_bool_type() const
    { return this->get()? &self_t::unspecified_bool_type_func : 0; }
 
- //!Not operator. Not needed in theory, but improves portability.
+ //!Not operator. Not needed in theory, but improves portability.
    //!Never throws.
    bool operator! () const
    { return this->get() == 0; }
 /*
    friend void swap (smart_ptr &pt, smart_ptr &pt2)
- {
+ {
       value_type *ptr = pt.get();
       pt = pt2;
       pt2 = ptr;
@@ -237,67 +237,67 @@
 
 //!smart_ptr<T1> == smart_ptr<T2>. Never throws.
 template<class T1, class T2>
-inline bool operator== (const smart_ptr<T1> &pt1,
+inline bool operator== (const smart_ptr<T1> &pt1,
                         const smart_ptr<T2> &pt2)
 { return pt1.get() == pt2.get(); }
 
 //!smart_ptr<T1> != smart_ptr<T2>. Never throws.
 template<class T1, class T2>
-inline bool operator!= (const smart_ptr<T1> &pt1,
+inline bool operator!= (const smart_ptr<T1> &pt1,
                         const smart_ptr<T2> &pt2)
 { return pt1.get() != pt2.get(); }
 
 //!smart_ptr<T1> < smart_ptr<T2>. Never throws.
 template<class T1, class T2>
-inline bool operator< (const smart_ptr<T1> &pt1,
+inline bool operator< (const smart_ptr<T1> &pt1,
                        const smart_ptr<T2> &pt2)
 { return pt1.get() < pt2.get(); }
 
 //!smart_ptr<T1> <= smart_ptr<T2>. Never throws.
 template<class T1, class T2>
-inline bool operator<= (const smart_ptr<T1> &pt1,
+inline bool operator<= (const smart_ptr<T1> &pt1,
                         const smart_ptr<T2> &pt2)
 { return pt1.get() <= pt2.get(); }
 
 //!smart_ptr<T1> > smart_ptr<T2>. Never throws.
 template<class T1, class T2>
-inline bool operator> (const smart_ptr<T1> &pt1,
+inline bool operator> (const smart_ptr<T1> &pt1,
                        const smart_ptr<T2> &pt2)
 { return pt1.get() > pt2.get(); }
 
 //!smart_ptr<T1> >= smart_ptr<T2>. Never throws.
 template<class T1, class T2>
-inline bool operator>= (const smart_ptr<T1> &pt1,
+inline bool operator>= (const smart_ptr<T1> &pt1,
                         const smart_ptr<T2> &pt2)
 { return pt1.get() >= pt2.get(); }
 
-//!operator<<
-template<class E, class T, class Y>
-inline std::basic_ostream<E, T> & operator<<
+//!operator<<
+template<class E, class T, class Y>
+inline std::basic_ostream<E, T> & operator<<
    (std::basic_ostream<E, T> & os, smart_ptr<Y> const & p)
 { return os << p.get(); }
 
-//!operator>>
-template<class E, class T, class Y>
-inline std::basic_istream<E, T> & operator>>
+//!operator>>
+template<class E, class T, class Y>
+inline std::basic_istream<E, T> & operator>>
    (std::basic_istream<E, T> & os, smart_ptr<Y> & p)
 { Y * tmp; return os >> tmp; p = tmp; }
 
-//!std::ptrdiff_t + smart_ptr
+//!std::ptrdiff_t + smart_ptr
 template<class T>
 inline smart_ptr<T> operator+(std::ptrdiff_t diff, const smart_ptr<T>& right)
 { return right + diff; }
 
-//!smart_ptr - smart_ptr
+//!smart_ptr - smart_ptr
 template<class T, class T2>
 inline std::ptrdiff_t operator- (const smart_ptr<T> &pt, const smart_ptr<T2> &pt2)
 { return pt.get()- pt2.get(); }
 
-//!swap specialization
+//!swap specialization
 template<class T>
-inline void swap (smart_ptr<T> &pt,
+inline void swap (smart_ptr<T> &pt,
                   smart_ptr<T> &pt2)
-{
+{
    typename smart_ptr<T>::value_type *ptr = pt.get();
    pt = pt2;
    pt2 = ptr;
@@ -310,35 +310,35 @@
 { return p.get(); }
 
 //!Simulation of static_cast between pointers. Never throws.
-template<class T, class U>
-inline smart_ptr<T>
+template<class T, class U>
+inline smart_ptr<T>
    static_pointer_cast(smart_ptr<U> const & r)
-{
- return smart_ptr<T>(r, detail::static_cast_tag());
+{
+ return smart_ptr<T>(r, detail::static_cast_tag());
 }
 
 //!Simulation of const_cast between pointers. Never throws.
-template<class T, class U>
+template<class T, class U>
 inline smart_ptr<T>const_pointer_cast(smart_ptr<U> const & r)
-{
- return smart_ptr<T>(r, detail::const_cast_tag());
+{
+ return smart_ptr<T>(r, detail::const_cast_tag());
 }
 
 //!Simulation of dynamic_cast between pointers. Never throws.
-template<class T, class U>
-inline smart_ptr<T>
+template<class T, class U>
+inline smart_ptr<T>
    dynamic_pointer_cast(smart_ptr<U> const & r)
-{
+{
    return smart_ptr<T>
- (r, detail::dynamic_cast_tag());
+ (r, detail::dynamic_cast_tag());
 }
 
 //!Simulation of reinterpret_cast between pointers. Never throws.
-template<class T, class U>
+template<class T, class U>
 inline smart_ptr<T>
    reinterpret_pointer_cast(smart_ptr<U> const & r)
-{
- return smart_ptr<T>(r, detail::reinterpret_cast_tag());
+{
+ return smart_ptr<T>(r, detail::reinterpret_cast_tag());
 }
 
 } //namespace intrusive {


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk