Subject: [Boost-commit] svn:boost r55074 - sandbox/fmhess/boost/smart_ptr
From: fmhess_at_[hidden]
Date: 2009-07-21 14:29:02
Author: fmhess
Date: 2009-07-21 14:29:01 EDT (Tue, 21 Jul 2009)
New Revision: 55074
URL: http://svn.boost.org/trac/boost/changeset/55074
Log:
Added enable_generic_shared_from_this.hpp. All smart_ptr tests pass now
using shared_ptr/weak_ptr/enabled_shared_from_this implementations built
on top of generic_shared/generic_weak/enable_generic_shared_from_this,
except for the one test that uses enable_shared_from_this2.
Added:
sandbox/fmhess/boost/smart_ptr/enable_generic_shared_from_this.hpp
- copied, changed from r55073, /trunk/boost/smart_ptr/enable_shared_from_this.hpp
sandbox/fmhess/boost/smart_ptr/enable_shared_from_this.hpp (contents, props changed)
Text files modified:
sandbox/fmhess/boost/smart_ptr/enable_generic_shared_from_this.hpp | 41 +++++++++--------
sandbox/fmhess/boost/smart_ptr/generic_shared.hpp | 90 ++++++++++++++++++++++++++++++++++-----
sandbox/fmhess/boost/smart_ptr/shared_ptr.hpp | 33 ++++++++++++-
3 files changed, 127 insertions(+), 37 deletions(-)
Copied: sandbox/fmhess/boost/smart_ptr/enable_generic_shared_from_this.hpp (from r55073, /trunk/boost/smart_ptr/enable_shared_from_this.hpp)
==============================================================================
--- /trunk/boost/smart_ptr/enable_shared_from_this.hpp (original)
+++ sandbox/fmhess/boost/smart_ptr/enable_generic_shared_from_this.hpp 2009-07-21 14:29:01 EDT (Tue, 21 Jul 2009)
@@ -1,10 +1,11 @@
-#ifndef BOOST_SMART_PTR_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
-#define BOOST_SMART_PTR_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
+#ifndef BOOST_SMART_PTR_ENABLE_GENERIC_SHARED_FROM_THIS_HPP_INCLUDED
+#define BOOST_SMART_PTR_ENABLE_GENERIC_SHARED_FROM_THIS_HPP_INCLUDED
//
-// enable_shared_from_this.hpp
+// enable_generic_shared_from_this.hpp
//
// Copyright 2002, 2009 Peter Dimov
+// Copyright 2009 Frank Mori Hess
//
// Distributed under the Boost Software License, Version 1.0.
// See accompanying file LICENSE_1_0.txt or copy at
@@ -13,67 +14,67 @@
// http://www.boost.org/libs/smart_ptr/enable_shared_from_this.html
//
-#include <boost/smart_ptr/weak_ptr.hpp>
-#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/generic_weak.hpp>
+#include <boost/smart_ptr/generic_shared.hpp>
#include <boost/assert.hpp>
#include <boost/config.hpp>
namespace boost
{
-template<class T> class enable_shared_from_this
+template<class T> class enable_generic_shared_from_this
{
protected:
- enable_shared_from_this()
+ enable_generic_shared_from_this()
{
}
- enable_shared_from_this(enable_shared_from_this const &)
+ enable_generic_shared_from_this(enable_generic_shared_from_this const &)
{
}
- enable_shared_from_this & operator=(enable_shared_from_this const &)
+ enable_generic_shared_from_this & operator=(enable_generic_shared_from_this const &)
{
return *this;
}
- ~enable_shared_from_this()
+ ~enable_generic_shared_from_this()
{
}
public:
- shared_ptr<T> shared_from_this()
+ generic_shared<T> shared_from_this()
{
- shared_ptr<T> p( weak_this_ );
+ generic_shared<T> p( weak_this_ );
BOOST_ASSERT( p.get() == this );
return p;
}
-
- shared_ptr<T const> shared_from_this() const
+//FIXME: yikes! we need to make it easier to add/remove const from a generic pointer's value_type
+ typename generic_shared<T>::template rebind<typename generic_shared<T>::value_type const>::other shared_from_this() const
{
- shared_ptr<T const> p( weak_this_ );
+ typename generic_shared<T>::template rebind<typename generic_shared<T>::value_type const>::other p( weak_this_ );
BOOST_ASSERT( p.get() == this );
return p;
}
public: // actually private, but avoids compiler template friendship issues
- // Note: invoked automatically by shared_ptr; do not call
- template<class X, class Y> void _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const
+ // Note: invoked automatically by generic_shared; do not call
+ template<class X, class Y> void _internal_accept_owner( generic_shared<X> const * ppx, Y py ) const
{
if( weak_this_.expired() )
{
- weak_this_ = shared_ptr<T>( *ppx, py );
+ weak_this_ = generic_shared<T>( *ppx, py );
}
}
private:
- mutable weak_ptr<T> weak_this_;
+ mutable generic_weak<T> weak_this_;
};
} // namespace boost
-#endif // #ifndef BOOST_SMART_PTR_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
+#endif // #ifndef BOOST_SMART_PTR_ENABLE_GENERIC_SHARED_FROM_THIS_HPP_INCLUDED
Added: sandbox/fmhess/boost/smart_ptr/enable_shared_from_this.hpp
==============================================================================
--- (empty file)
+++ sandbox/fmhess/boost/smart_ptr/enable_shared_from_this.hpp 2009-07-21 14:29:01 EDT (Tue, 21 Jul 2009)
@@ -0,0 +1,35 @@
+#ifndef BOOST_SMART_PTR_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
+#define BOOST_SMART_PTR_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
+
+// Implementation of enable_shared_from_this as wrapper around
+// enable_generic_shared_from_this.
+// Written primarily to help test generic_shared using unmodified
+// shared_ptr tests.
+
+// Copyright (c) 2009 Frank Mori Hess
+//
+// 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)
+
+#include <boost/smart_ptr/enable_generic_shared_from_this.hpp>
+
+namespace boost
+{
+ template<typename T>
+ class enable_shared_from_this: public enable_generic_shared_from_this<T*>
+ {
+ typedef enable_generic_shared_from_this<T*> base_type;
+ public:
+ boost::shared_ptr<T> shared_from_this()
+ {
+ return base_type::shared_from_this();
+ }
+ boost::shared_ptr<const T> shared_from_this() const
+ {
+ return base_type::shared_from_this();
+ }
+ };
+}
+
+#endif // #ifndef BOOST_SMART_PTR_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
Modified: sandbox/fmhess/boost/smart_ptr/generic_shared.hpp
==============================================================================
--- sandbox/fmhess/boost/smart_ptr/generic_shared.hpp (original)
+++ sandbox/fmhess/boost/smart_ptr/generic_shared.hpp 2009-07-21 14:29:01 EDT (Tue, 21 Jul 2009)
@@ -22,6 +22,7 @@
// is_null_pointer() free function findable by ADL
// (in)equality comparison
// 2 argument static/const/dynamic_pointer_cast findable by ADL if you want support for casting
+// get_pointer support
#include <boost/config.hpp> // for broken compiler workarounds
@@ -44,6 +45,8 @@
#include <boost/smart_ptr/detail/shared_count.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/smart_ptr/detail/sp_convertible.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/utility/enable_if.hpp>
#if !defined(BOOST_SP_NO_ATOMIC_ACCESS)
#include <boost/smart_ptr/detail/spinlock_pool.hpp>
@@ -70,17 +73,18 @@
namespace boost
{
-template<class T> class generic_shared;
-template<class T> class generic_weak;
+template<typename T> class generic_shared;
+template<typename T> class generic_weak;
+template<typename T> class enable_generic_shared_from_this;
-template<class T> struct smart_pointer_traits
+template<typename T> struct smart_pointer_traits
{
typedef typename T::value_type value_type;
typedef typename T::pointer pointer;
typedef typename T::reference reference;
};
-template<class T> struct smart_pointer_traits<T*>
+template<typename T> struct smart_pointer_traits<T*>
{
typedef T value_type;
typedef T * pointer;
@@ -115,6 +119,31 @@
typedef void reference;
};
+template<typename GenericPtr, typename ValueType>
+struct rebind_generic_ptr
+{
+ typedef typename GenericPtr::template rebind<ValueType>::other other;
+};
+
+template<typename T, typename ValueType>
+struct rebind_generic_ptr<T*, ValueType>
+{
+ typedef ValueType * other;
+};
+
+template<typename GenericPtr>
+typename smart_pointer_traits<GenericPtr>::value_type *
+ get_plain_old_pointer(GenericPtr gp)
+{
+ return get_plain_old_pointer(get_pointer(gp));
+}
+
+template<typename T>
+T * get_plain_old_pointer(T * p)
+{
+ return p;
+}
+
template<typename T> bool is_null_pointer(const generic_shared<T> &p)
{
return !p;
@@ -150,11 +179,40 @@
struct const_cast_tag {};
struct dynamic_cast_tag {};
-template<typename T, typename U, typename V>
-inline void sp_enable_shared_from_this(T, U, V)
+// enable_shared_from_this support
+
+template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::generic_shared<X> const * ppx, Y const * py,
+ boost::enable_generic_shared_from_this< T > const * pe )
{
+ if( pe != 0 )
+ {
+//FIXME: yikes! this const cast is painful
+ typedef typename rebind_generic_ptr<Y, typename remove_const<typename smart_pointer_traits<Y>::value_type>::type>::other nonconst_y_type;
+ pe->_internal_accept_owner( ppx, const_pointer_cast<typename smart_pointer_traits<nonconst_y_type>::value_type>( *py ) );
+ }
}
+#ifdef _MANAGED
+
+// Avoid C4793, ... causes native code generation
+
+struct sp_any_pointer
+{
+ template<class T> sp_any_pointer( T* ) {}
+};
+
+inline void sp_enable_shared_from_this( sp_any_pointer, sp_any_pointer, sp_any_pointer )
+{
+}
+
+#else // _MANAGED
+
+inline void sp_enable_shared_from_this( ... )
+{
+}
+
+#endif // _MANAGED
+
#if !defined( BOOST_NO_SFINAE ) && !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined( BOOST_NO_AUTO_PTR )
// rvalue auto_ptr support based on a technique by Dave Abrahams
@@ -210,6 +268,12 @@
typedef typename boost::smart_pointer_traits<T>::reference reference;
typedef generic_weak<T> weak_type;
+ template<typename ValueType>
+ struct rebind
+ {
+ typedef generic_shared<typename rebind_generic_ptr<pointer, ValueType>::other > other;
+ };
+
generic_shared(): px(), pn()
{
}
@@ -217,7 +281,7 @@
template<class Y>
explicit generic_shared( Y p ): px( p ), pn( p ) // Y must be complete
{
- boost::gs_detail::sp_enable_shared_from_this( this, p, p );
+ boost::gs_detail::sp_enable_shared_from_this( this, &p, get_plain_old_pointer(p) );
}
//
@@ -228,14 +292,14 @@
template<class Y, class D> generic_shared(Y p, D d): px(p), pn(p, d)
{
- boost::gs_detail::sp_enable_shared_from_this( this, p, p );
+ boost::gs_detail::sp_enable_shared_from_this( this, &p, get_plain_old_pointer(p) );
}
// As above, but with allocator. A's copy constructor shall not throw.
template<class Y, class D, class A> generic_shared( Y p, D d, A a ): px( p ), pn( p, d, a )
{
- boost::gs_detail::sp_enable_shared_from_this( this, p, p );
+ boost::gs_detail::sp_enable_shared_from_this( this, &p, get_plain_old_pointer(p) );
}
// generated copy constructor, destructor are fine
@@ -271,8 +335,8 @@
}
// aliasing
- template< class Y >
- generic_shared( generic_shared<Y> const & r, T p ): px( p ), pn( r.pn ) // never throws
+ template< class Y, class Z >
+ generic_shared( generic_shared<Y> const & r, Z p ): px( p ), pn( r.pn ) // never throws
{
}
@@ -309,7 +373,7 @@
{
Y * tmp = r.get();
pn = boost::detail::shared_count(r);
- boost::gs_detail::sp_enable_shared_from_this( this, tmp, tmp );
+ boost::gs_detail::sp_enable_shared_from_this( this, &tmp, get_plain_old_pointer(tmp) );
}
#if !defined( BOOST_NO_SFINAE ) && !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
@@ -319,7 +383,7 @@
{
typename Ap::element_type * tmp = r.get();
pn = boost::detail::shared_count( r );
- boost::gs_detail::sp_enable_shared_from_this( this, tmp, tmp );
+ boost::gs_detail::sp_enable_shared_from_this( this, &tmp, get_plain_old_pointer(tmp) );
}
Modified: sandbox/fmhess/boost/smart_ptr/shared_ptr.hpp
==============================================================================
--- sandbox/fmhess/boost/smart_ptr/shared_ptr.hpp (original)
+++ sandbox/fmhess/boost/smart_ptr/shared_ptr.hpp 2009-07-21 14:29:01 EDT (Tue, 21 Jul 2009)
@@ -15,15 +15,40 @@
namespace boost
{
+ template<typename T> class enable_shared_from_this;
+ template<typename T> class shared_ptr;
+ template<typename T> class weak_ptr;
+
namespace detail
{
- template<typename T, typename U, typename V>
- inline void sp_enable_shared_from_this(T, U, V)
+ // enable_shared_from_this support
+
+ template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
{
+ gs_detail::sp_enable_shared_from_this(static_cast<generic_shared<X*> const *>(ppx), &py, pe);
}
- }
- template<typename T> class weak_ptr;
+ #ifdef _MANAGED
+
+ // Avoid C4793, ... causes native code generation
+
+ struct sp_any_pointer
+ {
+ template<class T> sp_any_pointer( T* ) {}
+ };
+
+ inline void sp_enable_shared_from_this( sp_any_pointer, sp_any_pointer, sp_any_pointer )
+ {
+ }
+
+ #else // _MANAGED
+
+ inline void sp_enable_shared_from_this( ... )
+ {
+ }
+
+ #endif // _MANAGED
+ }
template<typename T>
class shared_ptr: public generic_shared<T*>