FreeChainXenon/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

re PR libstdc++/36962 ([C++0x] Add constructors / assignment operators from unique_ptr to shared_ptr)

Browse source 
PR libstdc++/36962
	* include/Makefile.am: Update headers.
	* include/Makefile.in: Regenerate.
	* include/std/memory: Update headers.
	* include/tr1/memory: Likewise.
	* include/tr1_impl/boost_shared_ptr.h: Remove, splitting into
	separate implementations for std and tr1.
	* include/bits/boost_sp_shared_count.h: Remove.
	* include/tr1/boost_sp_shared_count.h: Remove.
	* include/bits/shared_ptr.h: New. Combines boost_sp_shared_count.h
	and boost_shared_ptr.h into one file.
	(__shared_count,__shared_ptr,shared_ptr,swap): Add unique_ptr
	and rvalue-reference support as per current WP.
	* include/tr1/shared_ptr.h: New. Combines boost_sp_shared_count.h
	and boost_shared_ptr.h into one file.
	* testsuite/20_util/shared_ptr/cons/unique_ptr.cc: New.
	* testsuite/20_util/shared_ptr/cons/unique_ptr_deleter.cc: New.
	* testsuite/20_util/shared_ptr/cons/unique_ptr_deleter_ref.cc: New.
	* testsuite/20_util/shared_ptr/cons/unique_ptr_neg.cc: New.
	* testsuite/20_util/shared_ptr/assign/auto_ptr_rvalue.cc: New.
	* testsuite/20_util/shared_ptr/assign/unique_ptr_lvalue_neg.cc: New.
	* testsuite/20_util/shared_ptr/assign/unique_ptr_rvalue.cc: New.
	* testsuite/20_util/shared_ptr/modifiers/swap_rvalue.cc: New.
	* testsuite/20_util/shared_ptr/assign/auto_ptr_rvalue_neg.cc: Remove.

From-SVN: r140012
This commit is contained in:
Jonathan Wakely 2008-09-04 22:33:10 +00:00 • committed by Jonathan Wakely
parent 5299815b88
commit 640cbe76c7
17 changed files with 2061 additions and 893 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
libstdc++-v3/ChangeLog
View file

@ -1,3 +1,30 @@
2008-09-04 Jonathan Wakely <jwakely.gcc@gmail.com>
PR libstdc++/36962
* include/Makefile.am: Update headers.
* include/Makefile.in: Regenerate.
* include/std/memory: Update headers.
* include/tr1/memory: Likewise.
* include/tr1_impl/boost_shared_ptr.h: Remove, splitting into
separate implementations for std and tr1.
* include/bits/boost_sp_shared_count.h: Remove.
* include/tr1/boost_sp_shared_count.h: Remove.
* include/bits/shared_ptr.h: New. Combines boost_sp_shared_count.h
and boost_shared_ptr.h into one file.
(__shared_count,__shared_ptr,shared_ptr,swap): Add unique_ptr
and rvalue-reference support as per current WP.
* include/tr1/shared_ptr.h: New. Combines boost_sp_shared_count.h
and boost_shared_ptr.h into one file.
* testsuite/20_util/shared_ptr/cons/unique_ptr.cc: New.
* testsuite/20_util/shared_ptr/cons/unique_ptr_deleter.cc: New.
* testsuite/20_util/shared_ptr/cons/unique_ptr_deleter_ref.cc: New.
* testsuite/20_util/shared_ptr/cons/unique_ptr_neg.cc: New.
* testsuite/20_util/shared_ptr/assign/auto_ptr_rvalue.cc: New.
* testsuite/20_util/shared_ptr/assign/unique_ptr_lvalue_neg.cc: New.
* testsuite/20_util/shared_ptr/assign/unique_ptr_rvalue.cc: New.
* testsuite/20_util/shared_ptr/modifiers/swap_rvalue.cc: New.
* testsuite/20_util/shared_ptr/assign/auto_ptr_rvalue_neg.cc: Remove.
2008-09-04 Jonathan Wakely <jwakely.gcc@gmail.com>
* doc/xml/manual/locale.xml: Fix typo.

5
libstdc++-v3/include/Makefile.am
View file

@ -81,7 +81,6 @@ bits_headers = \
${bits_srcdir}/basic_string.h \
${bits_srcdir}/basic_string.tcc \
${bits_srcdir}/boost_concept_check.h \
${bits_srcdir}/boost_sp_shared_count.h \
${bits_srcdir}/char_traits.h \
${bits_srcdir}/codecvt.h \
${bits_srcdir}/concept_check.h \
@ -111,6 +110,7 @@ bits_headers = \
${bits_srcdir}/postypes.h \
${bits_srcdir}/stream_iterator.h \
${bits_srcdir}/streambuf_iterator.h \
${bits_srcdir}/shared_ptr.h \
${bits_srcdir}/slice_array.h \
${bits_srcdir}/sstream.tcc \
${bits_srcdir}/stl_algo.h \
@ -522,7 +522,6 @@ tr1_headers = \
${tr1_srcdir}/array \
${tr1_srcdir}/bessel_function.tcc \
${tr1_srcdir}/beta_function.tcc \
${tr1_srcdir}/boost_sp_shared_count.h \
${tr1_srcdir}/ccomplex \
${tr1_srcdir}/cctype \
${tr1_srcdir}/cfenv \
@ -562,6 +561,7 @@ tr1_headers = \
${tr1_srcdir}/random \
${tr1_srcdir}/regex \
${tr1_srcdir}/riemann_zeta.tcc \
${tr1_srcdir}/shared_ptr.h \
${tr1_srcdir}/special_function_util.h \
${tr1_srcdir}/stdarg.h \
${tr1_srcdir}/stdbool.h \
@ -582,7 +582,6 @@ tr1_impl_srcdir = ${glibcxx_srcdir}/include/tr1_impl
tr1_impl_builddir = ./tr1_impl
tr1_impl_headers = \
${tr1_impl_srcdir}/array \
${tr1_impl_srcdir}/boost_shared_ptr.h \
${tr1_impl_srcdir}/boost_sp_counted_base.h \
${tr1_impl_srcdir}/cctype \
${tr1_impl_srcdir}/cfenv \

5
libstdc++-v3/include/Makefile.in
View file

@ -335,7 +335,6 @@ bits_headers = \
${bits_srcdir}/basic_string.h \
${bits_srcdir}/basic_string.tcc \
${bits_srcdir}/boost_concept_check.h \
${bits_srcdir}/boost_sp_shared_count.h \
${bits_srcdir}/char_traits.h \
${bits_srcdir}/codecvt.h \
${bits_srcdir}/concept_check.h \
@ -365,6 +364,7 @@ bits_headers = \
${bits_srcdir}/postypes.h \
${bits_srcdir}/stream_iterator.h \
${bits_srcdir}/streambuf_iterator.h \
${bits_srcdir}/shared_ptr.h \
${bits_srcdir}/slice_array.h \
${bits_srcdir}/sstream.tcc \
${bits_srcdir}/stl_algo.h \
@ -774,7 +774,6 @@ tr1_headers = \
${tr1_srcdir}/array \
${tr1_srcdir}/bessel_function.tcc \
${tr1_srcdir}/beta_function.tcc \
${tr1_srcdir}/boost_sp_shared_count.h \
${tr1_srcdir}/ccomplex \
${tr1_srcdir}/cctype \
${tr1_srcdir}/cfenv \
@ -814,6 +813,7 @@ tr1_headers = \
${tr1_srcdir}/random \
${tr1_srcdir}/regex \
${tr1_srcdir}/riemann_zeta.tcc \
${tr1_srcdir}/shared_ptr.h \
${tr1_srcdir}/special_function_util.h \
${tr1_srcdir}/stdarg.h \
${tr1_srcdir}/stdbool.h \
@ -833,7 +833,6 @@ tr1_impl_srcdir = ${glibcxx_srcdir}/include/tr1_impl
tr1_impl_builddir = ./tr1_impl
tr1_impl_headers = \
${tr1_impl_srcdir}/array \
${tr1_impl_srcdir}/boost_shared_ptr.h \
${tr1_impl_srcdir}/boost_sp_counted_base.h \
${tr1_impl_srcdir}/cctype \
${tr1_impl_srcdir}/cfenv \

378
libstdc++-v3/include/bits/boost_sp_shared_count.h
View file

@ -1,378 +0,0 @@
// <bits/boost_sp_shared_count.h> -*- C++ -*-
// Copyright (C) 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
// shared_count.hpp
// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
// shared_ptr.hpp
// Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
// Copyright (C) 2001, 2002, 2003 Peter Dimov
// weak_ptr.hpp
// Copyright (C) 2001, 2002, 2003 Peter Dimov
// enable_shared_from_this.hpp
// Copyright (C) 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)
// GCC Note: based on version 1.32.0 of the Boost library.
/** @file bits/boost_sp_shared_count.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#ifndef __GXX_EXPERIMENTAL_CXX0X__
# include <c++0x_warning.h>
#endif
#if defined(_GLIBCXX_INCLUDE_AS_TR1)
# error C++0x header cannot be included from TR1 header
#endif
namespace std
{
// counted ptr with no deleter or allocator support
template<typename _Ptr, _Lock_policy _Lp>
class _Sp_counted_ptr
: public _Sp_counted_base<_Lp>
{
public:
_Sp_counted_ptr(_Ptr __p)
: _M_ptr(__p) { }
virtual void
_M_dispose() // nothrow
{ delete _M_ptr; }
virtual void
_M_destroy() // nothrow
{ delete this; }
virtual void*
_M_get_deleter(const std::type_info& __ti)
{ return 0; }
private:
_Sp_counted_ptr(const _Sp_counted_ptr&);
_Sp_counted_ptr& operator=(const _Sp_counted_ptr&);
protected:
_Ptr _M_ptr; // copy constructor must not throw
};
// support for custom deleter and/or allocator
template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
class _Sp_counted_deleter
: public _Sp_counted_ptr<_Ptr, _Lp>
{
typedef typename _Alloc::template
rebind<_Sp_counted_deleter>::other _My_alloc_type;
// Helper class that stores the Deleter and also acts as an allocator.
// Used to dispose of the owned pointer and the internal refcount
// Requires that copies of _Alloc can free each other's memory.
struct _My_Deleter
: public _My_alloc_type // copy constructor must not throw
{
_Deleter _M_del; // copy constructor must not throw
_My_Deleter(_Deleter __d, const _Alloc& __a)
: _My_alloc_type(__a), _M_del(__d) { }
};
protected:
typedef _Sp_counted_ptr<_Ptr, _Lp> _Base_type;
public:
/**
* @brief
* @pre __d(__p) must not throw.
*/
_Sp_counted_deleter(_Ptr __p, _Deleter __d)
: _Base_type(__p), _M_del(__d, _Alloc()) { }
/**
* @brief
* @pre __d(__p) must not throw.
*/
_Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a)
: _Base_type(__p), _M_del(__d, __a) { }
virtual void
_M_dispose() // nothrow
{ _M_del._M_del(_Base_type::_M_ptr); }
virtual void
_M_destroy() // nothrow
{
_My_alloc_type __a(_M_del);
this->~_Sp_counted_deleter();
__a.deallocate(this, 1);
}
virtual void*
_M_get_deleter(const std::type_info& __ti)
{ return __ti == typeid(_Deleter) ? &_M_del._M_del : 0; }
private:
_Sp_counted_deleter(const _Sp_counted_deleter&);
_Sp_counted_deleter& operator=(const _Sp_counted_deleter&);
protected:
_My_Deleter _M_del; // copy constructor must not throw
};
// helpers for make_shared / allocate_shared
template<typename _Tp>
struct _Sp_destroy_inplace
{
void operator()(_Tp* __p) const { if (__p) __p->~_Tp(); }
};
struct _Sp_make_shared_tag { };
template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
class _Sp_counted_ptr_inplace
: public _Sp_counted_deleter<_Tp*, _Sp_destroy_inplace<_Tp>, _Alloc, _Lp>
{
typedef _Sp_counted_deleter<_Tp*, _Sp_destroy_inplace<_Tp>, _Alloc, _Lp>
_Base_type;
public:
_Sp_counted_ptr_inplace(_Alloc __a)
: _Base_type(static_cast<_Tp*>(0), _Sp_destroy_inplace<_Tp>(), __a)
, _M_storage()
{
void* __p = &_M_storage;
::new (__p) _Tp(); // might throw
_Base_type::_Base_type::_M_ptr = static_cast<_Tp*>(__p);
}
template<typename... _Args>
_Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
: _Base_type(static_cast<_Tp*>(0), _Sp_destroy_inplace<_Tp>(), __a)
, _M_storage()
{
void* __p = &_M_storage;
::new (__p) _Tp(std::forward<_Args>(__args)...); // might throw
_Base_type::_Base_type::_M_ptr = static_cast<_Tp*>(__p);
}
// override because the allocator needs to know the dynamic type
virtual void
_M_destroy() // nothrow
{
typedef typename _Alloc::template
rebind<_Sp_counted_ptr_inplace>::other _My_alloc_type;
_My_alloc_type __a(_Base_type::_M_del);
this->~_Sp_counted_ptr_inplace();
__a.deallocate(this, 1);
}
// sneaky trick so __shared_ptr can get the managed pointer
virtual void*
_M_get_deleter(const std::type_info& __ti)
{
return __ti == typeid(_Sp_make_shared_tag)
? static_cast<void*>(&_M_storage)
: _Base_type::_M_get_deleter(__ti);
}
private:
typename aligned_storage<sizeof(_Tp), alignment_of<_Tp>::value>::type
_M_storage;
};
template<_Lock_policy _Lp = __default_lock_policy>
class __weak_count;
template<_Lock_policy _Lp = __default_lock_policy>
class __shared_count
{
public:
__shared_count()
: _M_pi(0) // nothrow
{ }
template<typename _Ptr>
__shared_count(_Ptr __p) : _M_pi(0)
{
try
{
_M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
}
catch(...)
{
delete __p;
__throw_exception_again;
}
}
template<typename _Ptr, typename _Deleter>
__shared_count(_Ptr __p, _Deleter __d) : _M_pi(0)
{
// allocator's value_type doesn't matter, will rebind it anyway
typedef std::allocator<int> _Alloc;
typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
typedef std::allocator<_Sp_cd_type> _Alloc2;
_Alloc2 __a2;
try
{
_M_pi = __a2.allocate(1);
new(static_cast<void*>(_M_pi)) _Sp_cd_type(__p, __d);
}
catch(...)
{
__d(__p); // Call _Deleter on __p.
if (_M_pi)
__a2.deallocate(static_cast<_Sp_cd_type*>(_M_pi), 1);
__throw_exception_again;
}
}
template<typename _Ptr, typename _Deleter, typename _Alloc>
__shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
{
typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
typedef typename _Alloc::template rebind<_Sp_cd_type>::other _Alloc2;
_Alloc2 __a2(__a);
try
{
_M_pi = __a2.allocate(1);
new(static_cast<void*>(_M_pi)) _Sp_cd_type(__p, __d, __a);
}
catch(...)
{
__d(__p); // Call _Deleter on __p.
if (_M_pi)
__a2.deallocate(static_cast<_Sp_cd_type*>(_M_pi), 1);
__throw_exception_again;
}
}
template<typename _Tp, typename _Alloc, typename... _Args>
__shared_count(_Sp_make_shared_tag, _Tp*, _Alloc __a, _Args&&... __args)
: _M_pi(0)
{
typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
typedef typename _Alloc::template rebind<_Sp_cp_type>::other _Alloc2;
_Alloc2 __a2(__a);
try
{
_M_pi = __a2.allocate(1);
new(static_cast<void*>(_M_pi)) _Sp_cp_type(__a,
std::forward<_Args>(__args)...);
}
catch(...)
{
if (_M_pi)
__a2.deallocate(static_cast<_Sp_cp_type*>(_M_pi), 1);
__throw_exception_again;
}
}
#if _GLIBCXX_DEPRECATED
// Special case for auto_ptr<_Tp> to provide the strong guarantee.
template<typename _Tp>
explicit
__shared_count(std::auto_ptr<_Tp>& __r)
: _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get()))
{ __r.release(); }
#endif
// Throw bad_weak_ptr when __r._M_get_use_count() == 0.
explicit
__shared_count(const __weak_count<_Lp>& __r);
~__shared_count() // nothrow
{
if (_M_pi != 0)
_M_pi->_M_release();
}
__shared_count(const __shared_count& __r)
: _M_pi(__r._M_pi) // nothrow
{
if (_M_pi != 0)
_M_pi->_M_add_ref_copy();
}
__shared_count&
operator=(const __shared_count& __r) // nothrow
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != _M_pi)
{
if (__tmp != 0)
__tmp->_M_add_ref_copy();
if (_M_pi != 0)
_M_pi->_M_release();
_M_pi = __tmp;
}
return *this;
}
void
_M_swap(__shared_count& __r) // nothrow
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
}
long
_M_get_use_count() const // nothrow
{ return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
bool
_M_unique() const // nothrow
{ return this->_M_get_use_count() == 1; }
friend inline bool
operator==(const __shared_count& __a, const __shared_count& __b)
{ return __a._M_pi == __b._M_pi; }
friend inline bool
operator<(const __shared_count& __a, const __shared_count& __b)
{ return std::less<_Sp_counted_base<_Lp>*>()(__a._M_pi, __b._M_pi); }
void*
_M_get_deleter(const std::type_info& __ti) const
{ return _M_pi ? _M_pi->_M_get_deleter(__ti) : 0; }
private:
friend class __weak_count<_Lp>;
_Sp_counted_base<_Lp>* _M_pi;
};
}

1451
libstdc++-v3/include/bits/shared_ptr.h Normal file
View file

File diff suppressed because it is too large Load diff

7
libstdc++-v3/include/std/memory
View file

@ -72,21 +72,20 @@
# include <bits/unique_ptr.h>
# include <debug/debug.h>
# include <type_traits>
# include <functional>
# if _GLIBCXX_DEPRECATED
# include <backward/auto_ptr.h>
# endif
# if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
# include <tr1_impl/boost_sp_counted_base.h>
# include <bits/boost_sp_shared_count.h>
# include <tr1_impl/boost_shared_ptr.h>
# include <bits/shared_ptr.h>
# else
# define _GLIBCXX_INCLUDE_AS_CXX0X
# define _GLIBCXX_BEGIN_NAMESPACE_TR1
# define _GLIBCXX_END_NAMESPACE_TR1
# define _GLIBCXX_TR1
# include <tr1_impl/boost_sp_counted_base.h>
# include <bits/boost_sp_shared_count.h>
# include <tr1_impl/boost_shared_ptr.h>
# include <bits/shared_ptr.h>
# undef _GLIBCXX_TR1
# undef _GLIBCXX_END_NAMESPACE_TR1
# undef _GLIBCXX_BEGIN_NAMESPACE_TR1

214
libstdc++-v3/include/tr1/boost_sp_shared_count.h
View file

@ -1,214 +0,0 @@
// <tr1/boost_sp_shared_count.h> -*- C++ -*-
// Copyright (C) 2007 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
// shared_count.hpp
// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
// shared_ptr.hpp
// Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
// Copyright (C) 2001, 2002, 2003 Peter Dimov
// weak_ptr.hpp
// Copyright (C) 2001, 2002, 2003 Peter Dimov
// enable_shared_from_this.hpp
// Copyright (C) 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)
// GCC Note: based on version 1.32.0 of the Boost library.
/** @file tr1/boost_sp_shared_count.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
# error TR1 header cannot be included from C++0x header
#endif
namespace std
{
namespace tr1
{
template<typename _Ptr, typename _Deleter, _Lock_policy _Lp>
class _Sp_counted_base_impl
: public _Sp_counted_base<_Lp>
{
public:
/**
* @brief
* @pre __d(__p) must not throw.
*/
_Sp_counted_base_impl(_Ptr __p, _Deleter __d)
: _M_ptr(__p), _M_del(__d) { }
virtual void
_M_dispose() // nothrow
{ _M_del(_M_ptr); }
virtual void*
_M_get_deleter(const std::type_info& __ti)
{ return __ti == typeid(_Deleter) ? &_M_del : 0; }
private:
_Sp_counted_base_impl(const _Sp_counted_base_impl&);
_Sp_counted_base_impl& operator=(const _Sp_counted_base_impl&);
_Ptr _M_ptr; // copy constructor must not throw
_Deleter _M_del; // copy constructor must not throw
};
template<_Lock_policy _Lp = __default_lock_policy>
class __weak_count;
template<typename _Tp>
struct _Sp_deleter
{
typedef void result_type;
typedef _Tp* argument_type;
void operator()(_Tp* __p) const { delete __p; }
};
template<_Lock_policy _Lp = __default_lock_policy>
class __shared_count
{
public:
__shared_count()
: _M_pi(0) // nothrow
{ }
template<typename _Ptr>
__shared_count(_Ptr __p) : _M_pi(0)
{
try
{
typedef typename std::tr1::remove_pointer<_Ptr>::type _Tp;
_M_pi = new _Sp_counted_base_impl<_Ptr, _Sp_deleter<_Tp>, _Lp>(
__p, _Sp_deleter<_Tp>());
}
catch(...)
{
delete __p;
__throw_exception_again;
}
}
template<typename _Ptr, typename _Deleter>
__shared_count(_Ptr __p, _Deleter __d) : _M_pi(0)
{
try
{
_M_pi = new _Sp_counted_base_impl<_Ptr, _Deleter, _Lp>(__p, __d);
}
catch(...)
{
__d(__p); // Call _Deleter on __p.
__throw_exception_again;
}
}
// Special case for auto_ptr<_Tp> to provide the strong guarantee.
template<typename _Tp>
explicit
__shared_count(std::auto_ptr<_Tp>& __r)
: _M_pi(new _Sp_counted_base_impl<_Tp*,
_Sp_deleter<_Tp>, _Lp >(__r.get(), _Sp_deleter<_Tp>()))
{ __r.release(); }
// Throw bad_weak_ptr when __r._M_get_use_count() == 0.
explicit
__shared_count(const __weak_count<_Lp>& __r);
~__shared_count() // nothrow
{
if (_M_pi != 0)
_M_pi->_M_release();
}
__shared_count(const __shared_count& __r)
: _M_pi(__r._M_pi) // nothrow
{
if (_M_pi != 0)
_M_pi->_M_add_ref_copy();
}
__shared_count&
operator=(const __shared_count& __r) // nothrow
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != _M_pi)
{
if (__tmp != 0)
__tmp->_M_add_ref_copy();
if (_M_pi != 0)
_M_pi->_M_release();
_M_pi = __tmp;
}
return *this;
}
void
_M_swap(__shared_count& __r) // nothrow
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
}
long
_M_get_use_count() const // nothrow
{ return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
bool
_M_unique() const // nothrow
{ return this->_M_get_use_count() == 1; }
friend inline bool
operator==(const __shared_count& __a, const __shared_count& __b)
{ return __a._M_pi == __b._M_pi; }
friend inline bool
operator<(const __shared_count& __a, const __shared_count& __b)
{ return std::less<_Sp_counted_base<_Lp>*>()(__a._M_pi, __b._M_pi); }
void*
_M_get_deleter(const std::type_info& __ti) const
{ return _M_pi ? _M_pi->_M_get_deleter(__ti) : 0; }
private:
friend class __weak_count<_Lp>;
_Sp_counted_base<_Lp>* _M_pi;
};
}
}

6
libstdc++-v3/include/tr1/memory
View file

@ -55,16 +55,14 @@
#if defined(_GLIBCXX_INCLUDE_AS_TR1)
# include <tr1_impl/boost_sp_counted_base.h>
# include <tr1/boost_sp_shared_count.h>
# include <tr1_impl/boost_shared_ptr.h>
# include <tr1/shared_ptr.h>
#else
# define _GLIBCXX_INCLUDE_AS_TR1
# define _GLIBCXX_BEGIN_NAMESPACE_TR1 namespace tr1 {
# define _GLIBCXX_END_NAMESPACE_TR1 }
# define _GLIBCXX_TR1 tr1::
# include <tr1_impl/boost_sp_counted_base.h>
# include <tr1/boost_sp_shared_count.h>
# include <tr1_impl/boost_shared_ptr.h>
# include <tr1/shared_ptr.h>
# undef _GLIBCXX_TR1
# undef _GLIBCXX_END_NAMESPACE_TR1
# undef _GLIBCXX_BEGIN_NAMESPACE_TR1

453
libstdc++-v3/include/tr1_impl/boost_shared_ptr.h → libstdc++-v3/include/tr1/shared_ptr.h
View file

@ -1,4 +1,4 @@
// <tr1_impl/boost_shared_ptr.h> -*- C++ -*-
// <tr1/shared_ptr.h> -*- C++ -*-
// Copyright (C) 2007, 2008 Free Software Foundation, Inc.
//
@ -46,15 +46,171 @@
// GCC Note: based on version 1.32.0 of the Boost library.
/** @file tr1_impl/boost_shared_ptr.h
/** @file tr1/shared_ptr.h
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/
#if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
# error TR1 header cannot be included from C++0x header
#endif
namespace std
{
_GLIBCXX_BEGIN_NAMESPACE_TR1
namespace tr1
{
template<typename _Ptr, typename _Deleter, _Lock_policy _Lp>
class _Sp_counted_base_impl
: public _Sp_counted_base<_Lp>
{
public:
/**
* @brief
* @pre __d(__p) must not throw.
*/
_Sp_counted_base_impl(_Ptr __p, _Deleter __d)
: _M_ptr(__p), _M_del(__d) { }
virtual void
_M_dispose() // nothrow
{ _M_del(_M_ptr); }
virtual void*
_M_get_deleter(const std::type_info& __ti)
{ return __ti == typeid(_Deleter) ? &_M_del : 0; }
private:
_Sp_counted_base_impl(const _Sp_counted_base_impl&);
_Sp_counted_base_impl& operator=(const _Sp_counted_base_impl&);
_Ptr _M_ptr; // copy constructor must not throw
_Deleter _M_del; // copy constructor must not throw
};
template<_Lock_policy _Lp = __default_lock_policy>
class __weak_count;
template<typename _Tp>
struct _Sp_deleter
{
typedef void result_type;
typedef _Tp* argument_type;
void operator()(_Tp* __p) const { delete __p; }
};
template<_Lock_policy _Lp = __default_lock_policy>
class __shared_count
{
public:
__shared_count()
: _M_pi(0) // nothrow
{ }
template<typename _Ptr>
__shared_count(_Ptr __p) : _M_pi(0)
{
try
{
typedef typename std::tr1::remove_pointer<_Ptr>::type _Tp;
_M_pi = new _Sp_counted_base_impl<_Ptr, _Sp_deleter<_Tp>, _Lp>(
__p, _Sp_deleter<_Tp>());
}
catch(...)
{
delete __p;
__throw_exception_again;
}
}
template<typename _Ptr, typename _Deleter>
__shared_count(_Ptr __p, _Deleter __d) : _M_pi(0)
{
try
{
_M_pi = new _Sp_counted_base_impl<_Ptr, _Deleter, _Lp>(__p, __d);
}
catch(...)
{
__d(__p); // Call _Deleter on __p.
__throw_exception_again;
}
}
// Special case for auto_ptr<_Tp> to provide the strong guarantee.
template<typename _Tp>
explicit
__shared_count(std::auto_ptr<_Tp>& __r)
: _M_pi(new _Sp_counted_base_impl<_Tp*,
_Sp_deleter<_Tp>, _Lp >(__r.get(), _Sp_deleter<_Tp>()))
{ __r.release(); }
// Throw bad_weak_ptr when __r._M_get_use_count() == 0.
explicit
__shared_count(const __weak_count<_Lp>& __r);
~__shared_count() // nothrow
{
if (_M_pi != 0)
_M_pi->_M_release();
}
__shared_count(const __shared_count& __r)
: _M_pi(__r._M_pi) // nothrow
{
if (_M_pi != 0)
_M_pi->_M_add_ref_copy();
}
__shared_count&
operator=(const __shared_count& __r) // nothrow
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != _M_pi)
{
if (__tmp != 0)
__tmp->_M_add_ref_copy();
if (_M_pi != 0)
_M_pi->_M_release();
_M_pi = __tmp;
}
return *this;
}
void
_M_swap(__shared_count& __r) // nothrow
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
}
long
_M_get_use_count() const // nothrow
{ return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
bool
_M_unique() const // nothrow
{ return this->_M_get_use_count() == 1; }
friend inline bool
operator==(const __shared_count& __a, const __shared_count& __b)
{ return __a._M_pi == __b._M_pi; }
friend inline bool
operator<(const __shared_count& __a, const __shared_count& __b)
{ return std::less<_Sp_counted_base<_Lp>*>()(__a._M_pi, __b._M_pi); }
void*
_M_get_deleter(const std::type_info& __ti) const
{ return _M_pi ? _M_pi->_M_get_deleter(__ti) : 0; }
private:
friend class __weak_count<_Lp>;
_Sp_counted_base<_Lp>* _M_pi;
};
template<_Lock_policy _Lp>
class __weak_count
@ -188,11 +344,9 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
{ }
#ifdef _GLIBCXX_INCLUDE_AS_TR1
struct __static_cast_tag { };
struct __const_cast_tag { };
struct __dynamic_cast_tag { };
#endif
/**
* @class __shared_ptr
@ -251,52 +405,6 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
__enable_shared_from_this_helper(_M_refcount, __p, __p);
}
#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
//
// Requirements: _Deleter's copy constructor and destructor must
// not throw _Alloc's copy constructor and destructor must not
// throw.
//
// __shared_ptr will release __p by calling __d(__p)
//
/** @brief Construct a %__shared_ptr that owns the pointer @a __p
* and the deleter @a __d.
* @param __p A pointer.
* @param __d A deleter.
* @param __a An allocator.
* @post use_count() == 1 && get() == __p
* @throw std::bad_alloc, in which case @a __d(__p) is called.
*/
template<typename _Tp1, typename _Deleter, typename _Alloc>
__shared_ptr(_Tp1* __p, _Deleter __d, const _Alloc& __a)
: _M_ptr(__p), _M_refcount(__p, __d, __a)
{
__glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
// TODO requires _Deleter CopyConstructible and __d(__p) well-formed
__enable_shared_from_this_helper(_M_refcount, __p, __p);
}
/** @brief Constructs a %__shared_ptr instance that stores @a __p
* and shares ownership with @a __r.
* @param __r A %__shared_ptr.
* @param __p A pointer that will remain valid while @a *__r is valid.
* @post get() == __p && use_count() == __r.use_count()
*
* This can be used to construct a @c shared_ptr to a sub-object
* of an object managed by an existing @c shared_ptr.
*
* @code
* shared_ptr< pair<int,int> > pii(new pair<int,int>());
* shared_ptr<int> pi(pii, &pii->first);
* assert(pii.use_count() == 2);
* @endcode
*/
template<typename _Tp1>
__shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, _Tp* __p)
: _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws
{ }
#endif
// generated copy constructor, assignment, destructor are fine.
/** @brief If @a __r is empty, constructs an empty %__shared_ptr;
@ -310,32 +418,6 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
{ __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) }
#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
/** @brief Move-constructs a %__shared_ptr instance from @a __r.
* @param __r A %__shared_ptr rvalue.
* @post *this contains the old value of @a __r, @a __r is empty.
*/
__shared_ptr(__shared_ptr&& __r)
: _M_ptr(__r._M_ptr), _M_refcount() // never throws
{
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = 0;
}
/** @brief Move-constructs a %__shared_ptr instance from @a __r.
* @param __r A %__shared_ptr rvalue.
* @post *this contains the old value of @a __r, @a __r is empty.
*/
template<typename _Tp1>
__shared_ptr(__shared_ptr<_Tp1, _Lp>&& __r)
: _M_ptr(__r._M_ptr), _M_refcount() // never throws
{
__glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = 0;
}
#endif
/** @brief Constructs a %__shared_ptr that shares ownership with @a __r
* and stores a copy of the pointer stored in @a __r.
* @param __r A weak_ptr.
@ -354,10 +436,10 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
_M_ptr = __r._M_ptr;
}
#if !defined(__GXX_EXPERIMENTAL_CXX0X__) || _GLIBCXX_DEPRECATED
/**
* @post use_count() == 1 and __r.get() == 0
*/
#if !defined(__GXX_EXPERIMENTAL_CXX0X__) || _GLIBCXX_DEPRECATED
template<typename _Tp1>
explicit
__shared_ptr(std::auto_ptr<_Tp1>& __r)
@ -369,9 +451,9 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
_M_refcount = __shared_count<_Lp>(__r);
__enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
}
#endif
#ifdef _GLIBCXX_INCLUDE_AS_TR1
template<typename _Tp1>
__shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __static_cast_tag)
: _M_ptr(static_cast<element_type*>(__r._M_ptr)),
@ -392,7 +474,6 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
if (_M_ptr == 0) // need to allocate new counter -- the cast failed
_M_refcount = __shared_count<_Lp>();
}
#endif
template<typename _Tp1>
__shared_ptr&
@ -413,23 +494,6 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
}
#endif
#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
__shared_ptr&
operator=(__shared_ptr&& __r)
{
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
template<class _Tp1>
__shared_ptr&
operator=(__shared_ptr<_Tp1, _Lp>&& __r)
{
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
#endif
void
reset() // never throws
{ __shared_ptr().swap(*this); }
@ -448,18 +512,8 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
reset(_Tp1* __p, _Deleter __d)
{ __shared_ptr(__p, __d).swap(*this); }
#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
template<typename _Tp1, typename _Deleter, typename _Alloc>
void
reset(_Tp1* __p, _Deleter __d, const _Alloc& __a)
{ __shared_ptr(__p, __d, __a).swap(*this); }
// Allow class instantiation when _Tp is [cv-qual] void.
typename std::add_lvalue_reference<_Tp>::type
#else
// Allow class instantiation when _Tp is [cv-qual] void.
typename std::tr1::add_reference<_Tp>::type
#endif
operator*() const // never throws
{
_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
@ -500,27 +554,6 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
_M_refcount._M_swap(__other._M_refcount);
}
#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
protected:
// This constructor is non-standard, it is used by allocate_shared.
template<typename _Alloc, typename... _Args>
__shared_ptr(_Sp_make_shared_tag __tag, _Alloc __a, _Args&&... __args)
: _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a,
std::forward<_Args>(__args)...)
{
// _M_ptr needs to point to the newly constructed object.
// This relies on _Sp_counted_ptr_inplace::_M_get_deleter.
void* __p = _M_refcount._M_get_deleter(typeid(__tag));
_M_ptr = static_cast<_Tp*>(__p);
__enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
}
template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
typename... _Args>
friend __shared_ptr<_Tp1, _Lp1>
__allocate_shared(_Alloc __a, _Args&&... __args);
#endif
private:
void*
_M_get_deleter(const std::type_info& __ti) const
@ -572,13 +605,7 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
inline __shared_ptr<_Tp, _Lp>
static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r)
{
#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp*>(__r.get()));
#else
return __shared_ptr<_Tp, _Lp>(__r, __static_cast_tag());
#endif
}
{ return __shared_ptr<_Tp, _Lp>(__r, __static_cast_tag()); }
/** @warning The seemingly equivalent
* <code>shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))</code>
@ -588,13 +615,7 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
inline __shared_ptr<_Tp, _Lp>
const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r)
{
#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
return __shared_ptr<_Tp, _Lp>(__r, const_cast<_Tp*>(__r.get()));
#else
return __shared_ptr<_Tp, _Lp>(__r, __const_cast_tag());
#endif
}
{ return __shared_ptr<_Tp, _Lp>(__r, __const_cast_tag()); }
/** @warning The seemingly equivalent
* <code>shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))</code>
@ -604,15 +625,7 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
inline __shared_ptr<_Tp, _Lp>
dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r)
{
#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
return __shared_ptr<_Tp, _Lp>(__r, __p);
return __shared_ptr<_Tp, _Lp>();
#else
return __shared_ptr<_Tp, _Lp>(__r, __dynamic_cast_tag());
#endif
}
{ return __shared_ptr<_Tp, _Lp>(__r, __dynamic_cast_tag()); }
// 2.2.3.7 shared_ptr I/O
template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
@ -834,30 +847,10 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
shared_ptr(_Tp1* __p, _Deleter __d)
: __shared_ptr<_Tp>(__p, __d) { }
#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
template<typename _Tp1, typename _Deleter, typename _Alloc>
shared_ptr(_Tp1* __p, _Deleter __d, const _Alloc& __a)
: __shared_ptr<_Tp>(__p, __d, __a) { }
// Aliasing constructor
template<typename _Tp1>
shared_ptr(const shared_ptr<_Tp1>& __r, _Tp* __p)
: __shared_ptr<_Tp>(__r, __p) { }
#endif
template<typename _Tp1>
shared_ptr(const shared_ptr<_Tp1>& __r)
: __shared_ptr<_Tp>(__r) { }
#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
shared_ptr(shared_ptr&& __r)
: __shared_ptr<_Tp>(std::move(__r)) { }
template<typename _Tp1>
shared_ptr(shared_ptr<_Tp1>&& __r)
: __shared_ptr<_Tp>(std::move(__r)) { }
#endif
template<typename _Tp1>
explicit
shared_ptr(const weak_ptr<_Tp1>& __r)
@ -870,7 +863,6 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
: __shared_ptr<_Tp>(__r) { }
#endif
#ifdef _GLIBCXX_INCLUDE_AS_TR1
template<typename _Tp1>
shared_ptr(const shared_ptr<_Tp1>& __r, __static_cast_tag)
: __shared_ptr<_Tp>(__r, __static_cast_tag()) { }
@ -882,7 +874,6 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
template<typename _Tp1>
shared_ptr(const shared_ptr<_Tp1>& __r, __dynamic_cast_tag)
: __shared_ptr<_Tp>(__r, __dynamic_cast_tag()) { }
#endif
template<typename _Tp1>
shared_ptr&
@ -901,72 +892,28 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
return *this;
}
#endif
#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
shared_ptr&
operator=(shared_ptr&& __r)
{
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
}
template<class _Tp1>
shared_ptr&
operator=(shared_ptr<_Tp1>&& __r)
{
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
}
#endif
#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
private:
// This constructor is non-standard, it is used by allocate_shared.
template<typename _Alloc, typename... _Args>
shared_ptr(_Sp_make_shared_tag __tag, _Alloc __a, _Args&&... __args)
: __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
{ }
template<typename _Tp1, typename _Alloc, typename... _Args>
friend shared_ptr<_Tp1>
allocate_shared(_Alloc __a, _Args&&... __args);
#endif
};
// 2.2.3.8 shared_ptr specialized algorithms.
template<typename _Tp>
inline void
swap(__shared_ptr<_Tp>& __a, __shared_ptr<_Tp>& __b)
{ __a.swap(__b); }
template<typename _Tp, typename _Tp1>
inline shared_ptr<_Tp>
static_pointer_cast(const shared_ptr<_Tp1>& __r)
{
#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get()));
#else
return shared_ptr<_Tp>(__r, __static_cast_tag());
#endif
}
{ return shared_ptr<_Tp>(__r, __static_cast_tag()); }
template<typename _Tp, typename _Tp1>
inline shared_ptr<_Tp>
const_pointer_cast(const shared_ptr<_Tp1>& __r)
{
#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
return shared_ptr<_Tp>(__r, const_cast<_Tp*>(__r.get()));
#else
return shared_ptr<_Tp>(__r, __const_cast_tag());
#endif
}
{ return shared_ptr<_Tp>(__r, __const_cast_tag()); }
template<typename _Tp, typename _Tp1>
inline shared_ptr<_Tp>
dynamic_pointer_cast(const shared_ptr<_Tp1>& __r)
{
#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
return shared_ptr<_Tp>(__r, __p);
return shared_ptr<_Tp>();
#else
return shared_ptr<_Tp>(__r, __dynamic_cast_tag());
#endif
}
{ return shared_ptr<_Tp>(__r, __dynamic_cast_tag()); }
/// weak_ptr
@ -1069,57 +1016,5 @@ _GLIBCXX_BEGIN_NAMESPACE_TR1
mutable weak_ptr<_Tp> _M_weak_this;
};
#ifdef _GLIBCXX_INCLUDE_AS_CXX0X
template<typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args>
inline __shared_ptr<_Tp, _Lp>
__allocate_shared(_Alloc __a, _Args&&... __args)
{
return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(),
std::forward<_Alloc>(__a), std::forward<_Args>(__args)...);
}
template<typename _Tp, _Lock_policy _Lp, typename... _Args>
inline __shared_ptr<_Tp, _Lp>
__make_shared(_Args&&... __args)
{
typedef typename std::remove_const<_Tp>::type _Tp_nc;
return __allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
std::forward<_Args>(__args)...);
}
/** @brief Create an object that is owned by a shared_ptr.
* @param __a An allocator.
* @param __args Arguments for the @a _Tp object's constructor.
* @return A shared_ptr that owns the newly created object.
* @throw An exception thrown from @a _Alloc::allocate or from the
* constructor of @a _Tp.
*
* A copy of @a __a will be used to allocate memory for the shared_ptr
* and the new object.
*/
template<typename _Tp, typename _Alloc, typename... _Args>
inline shared_ptr<_Tp>
allocate_shared(_Alloc __a, _Args&&... __args)
{
return shared_ptr<_Tp>(_Sp_make_shared_tag(), std::forward<_Alloc>(__a),
std::forward<_Args>(__args)...);
}
/** @brief Create an object that is owned by a shared_ptr.
* @param __args Arguments for the @a _Tp object's constructor.
* @return A shared_ptr that owns the newly created object.
* @throw std::bad_alloc, or an exception thrown from the
* constructor of @a _Tp.
*/
template<typename _Tp, typename... _Args>
inline shared_ptr<_Tp>
make_shared(_Args&&... __args)
{
typedef typename std::remove_const<_Tp>::type _Tp_nc;
return allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
std::forward<_Args>(__args)...);
}
#endif
_GLIBCXX_END_NAMESPACE_TR1
}
}

62
libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr_rvalue.cc Normal file
View file

@ -0,0 +1,62 @@
// { dg-options "-std=gnu++0x -Wno-deprecated" }
// { dg-do compile }
// Copyright (C) 2008 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
#include <memory>
#include <testsuite_hooks.h>
struct A { };
std::auto_ptr<A> source() { return std::auto_ptr<A>(); }
// 20.7.12.2.3 shared_ptr assignment [util.smartptr.shared.assign]
// Assignment from rvalue auto_ptr
int
test01()
{
bool test __attribute__((unused)) = true;
std::shared_ptr<A> a;
a = source();
return 0;
}
int
test02()
{
bool test __attribute__((unused)) = true;
std::shared_ptr<A> a;
std::auto_ptr<A> au;
a = std::move(au);
return 0;
}
int
main()
{
test01();
test02();
return 0;
}

14
libstdc++-v3/testsuite/20_util/shared_ptr/assign/auto_ptr_rvalue_neg.cc → libstdc++-v3/testsuite/20_util/shared_ptr/assign/unique_ptr_lvalue_neg.cc
View file

@ -1,7 +1,7 @@
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2005, 2006, 2007 Free Software Foundation
// Copyright (C) 2008 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
@ -19,24 +19,24 @@
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 20.6.6.2 Template class shared_ptr [util.smartptr.shared]
// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
#include <memory>
#include <testsuite_hooks.h>
struct A { };
std::auto_ptr<A> source() { return std::auto_ptr<A>(); }
// 20.6.6.2.3 shared_ptr assignment [util.smartptr.shared.assign]
// 20.7.12.2.3 shared_ptr assignment [util.smartptr.shared.assign]
// Assignment from rvalue auto_ptr
// Assignment from lvalue unique_ptr
int
test01()
{
bool test __attribute__((unused)) = true;
std::shared_ptr<A> a;
a = source(); // { dg-error "no match" }
std::unique_ptr<A> u;
a = u; // { dg-error "used here" }
return 0;
}
@ -47,4 +47,4 @@ main()
test01();
return 0;
}
// { dg-excess-errors "candidates are" }
// { dg-excess-errors "deleted function" }

62
libstdc++-v3/testsuite/20_util/shared_ptr/assign/unique_ptr_rvalue.cc Normal file
View file

@ -0,0 +1,62 @@
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2008 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
#include <memory>
#include <testsuite_hooks.h>
struct A { };
std::unique_ptr<A> source() { return std::unique_ptr<A>(); }
// 20.7.12.2.3 shared_ptr assignment [util.smartptr.shared.assign]
// Assignment from rvalue unique_ptr
int
test01()
{
bool test __attribute__((unused)) = true;
std::shared_ptr<A> a;
a = source();
return 0;
}
int
test02()
{
bool test __attribute__((unused)) = true;
std::shared_ptr<A> a;
std::unique_ptr<A> u;
a = std::move(u);
return 0;
}
int
main()
{
test01();
test02();
return 0;
}

50
libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr.cc Normal file
View file

@ -0,0 +1,50 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
#include <memory>
#include <testsuite_hooks.h>
struct A { };
// 20.7.12.2.1 shared_ptr constructors [util.smartptr.shared.const]
// Construction from unique_ptr
int
test01()
{
bool test __attribute__((unused)) = true;
std::unique_ptr<A> up(new A);
std::shared_ptr<A> sp(std::move(up));
VERIFY( up.get() == 0 );
VERIFY( sp.get() != 0 );
VERIFY( sp.use_count() == 1 );
return 0;
}
int
main()
{
test01();
return 0;
}

60
libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_deleter.cc Normal file
View file

@ -0,0 +1,60 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
#include <memory>
#include <testsuite_hooks.h>
struct A { };
struct D {
void operator()(A* p) const { delete p; ++count; }
static int count;
};
int D::count = 0;
// 20.7.12.2.1 shared_ptr constructors [util.smartptr.shared.const]
// Construction from unique_ptr
int
test01()
{
bool test __attribute__((unused)) = true;
std::unique_ptr<A, D> up(new A, D());
{
std::shared_ptr<A> sp(std::move(up));
VERIFY( up.get() == 0 );
VERIFY( sp.get() != 0 );
VERIFY( sp.use_count() == 1 );
}
VERIFY( D::count == 1 );
return 0;
}
int
main()
{
test01();
return 0;
}

61
libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_deleter_ref.cc Normal file
View file

@ -0,0 +1,61 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
#include <memory>
#include <testsuite_hooks.h>
struct A { };
struct D {
typedef void result_type;
void operator()(A* p) { delete p; ++count; }
int count;
};
// 20.7.12.2.1 shared_ptr constructors [util.smartptr.shared.const]
// Construction from unique_ptr
int
test01()
{
bool test __attribute__((unused)) = true;
D d = D();
std::unique_ptr<A, D&> up(new A, d);
{
std::shared_ptr<A> sp(std::move(up));
VERIFY( up.get() == 0 );
VERIFY( sp.get() != 0 );
VERIFY( sp.use_count() == 1 );
}
VERIFY( d.count == 1 );
return 0;
}
int
main()
{
test01();
return 0;
}

49
libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_neg.cc Normal file
View file

@ -0,0 +1,49 @@
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2008 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
#include <memory>
#include <testsuite_hooks.h>
struct A { };
// 20.7.12.2.1 shared_ptr constructors [util.smartptr.shared.const]
// Construction from lvalue unique_ptr
int
test01()
{
bool test __attribute__((unused)) = true;
std::unique_ptr<A> a;
std::shared_ptr<A> p(a); // { dg-error "used here" }
return 0;
}
int
main()
{
test01();
return 0;
}
// { dg-excess-errors "deleted function" }

48
libstdc++-v3/testsuite/20_util/shared_ptr/modifiers/swap_rvalue.cc Normal file
View file

@ -0,0 +1,48 @@
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2008 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
#include <memory>
#include <testsuite_hooks.h>
struct A { };
// 20.7.12.2.4 shared_ptr modifiers [util.smartptr.shared.mod]
// swap
int
test01()
{
bool test __attribute__((unused)) = true;
std::shared_ptr<A> p(new A);
p.swap(std::shared_ptr<A>(new A));
return 0;
}
int
main()
{
test01();
return 0;
}