mirrors/gcc
0
0
Fork 0
mirror of https://gcc.gnu.org/git/gcc.git synced 2024-12-12 05:13:50 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

revert: forward_list.h: Support non-standard pointer types

Browse Source 
2010-03-15  Paolo Carlini  <paolo.carlini@oracle.com>

	Revert:
	2008-11-11  Bob Walters  <bob.s.walters@gmail.com>

	* include/bits/forward_list.h: Support non-standard pointer types
	(_Fwd_list_node_base): Add _Alloc template parameter.
	(_Fwd_list_node<>): Likewise.
	(_Fwd_list_iterator<>): Likewise.
	(_Fwd_list_const_iterator<>): Likewise.
	(_Fwd_list_node_base::_M_next, _M_transfer_after, _M_reverse_after):
	Use _Alloc<_Tp>::pointer.
	(_Fwd_list_iterator<>::_M_node): Use _Node_base::_Pointer.
	(_Fwd_list_base<>::_M_get_node, _M_create_node, _M_create_node,
	_M_insert_after, _M_put_node, _M_erase_after): Likewise.
	(_Fwd_list_const_iterator<>::_M_node): use _Node_base::_Const_pointer.
	(forward_list<>): Use __static_pointer_cast in place of static_cast,
	and __const_pointer_cast in place of const_cast.
	* include/bits/forward_list.tcc
	(_Fwd_list_node<>::_M_sort_after): Using _Pointer typedefs in place
	of standard pointers, __static_pointer_cast in place of static_cast.
	(_Fwd_list_base<>::_Fwd_list_base, _M_insert_after, _M_erase_after):
	Likewise.
	(forward_list<>::_M_initialize_dispatch, _M_fill_initialize,
	splice_after, remove, remove_if, merge): Likewise.
	* testsuite/23_containers/forward_list/ext_pointer/modifiers/1.cc: New.
	* testsuite/23_containers/forward_list/ext_pointer/modifiers/2.cc:
	Likewise.
	* testsuite/23_containers/forward_list/ext_pointer/modifiers/3.cc:
	Likewise.
	* testsuite/23_containers/forward_list/ext_pointer/modifiers/4.cc:
	Likewise.
	* testsuite/23_containers/forward_list/ext_pointer/modifiers/5.cc:
	Likewise.
	* testsuite/23_containers/forward_list/ext_pointer/operations/1.cc:
	Likewise.
	* testsuite/23_containers/forward_list/ext_pointer/operations/2.cc:
	Likewise.
	* testsuite/23_containers/forward_list/ext_pointer/operations/3.cc:
	Likewise.
	* testsuite/23_containers/forward_list/ext_pointer/operations/4.cc:
	Likewise.
	* testsuite/23_containers/forward_list/ext_pointer/operations/5.cc:
	Likewise.
	* testsuite/23_containers/forward_list/ext_pointer/operations/6.cc:
	Likewise.
	* testsuite/23_containers/forward_list/ext_pointer/operations/7.cc:
	Likewise.
	* testsuite/23_containers/forward_list/ext_pointer/requirements/1.cc:
	Likewise.
	* testsuite/23_containers/forward_list/ext_pointer/requirements/
	explicit_instantiation/1.cc: Likewise.
	* testsuite/23_containers/forward_list/ext_pointer/requirements/
	explicit_instantiation/3.cc: Likewise.
	* testsuite/23_containers/forward_list/ext_pointer/1.cc: Likewise.

From-SVN: r157462
This commit is contained in:
Paolo Carlini 2010-03-15 17:02:16 +00:00 committed by Paolo Carlini
parent c217233895
commit 97ffcedf40
24 changed files with 219 additions and 1395 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,59 @@
2010-03-15 Paolo Carlini <paolo.carlini@oracle.com>
Revert:
2008-11-11 Bob Walters <bob.s.walters@gmail.com>
* include/bits/forward_list.h: Support non-standard pointer types
(_Fwd_list_node_base): Add _Alloc template parameter.
(_Fwd_list_node<>): Likewise.
(_Fwd_list_iterator<>): Likewise.
(_Fwd_list_const_iterator<>): Likewise.
(_Fwd_list_node_base::_M_next, _M_transfer_after, _M_reverse_after):
Use _Alloc<_Tp>::pointer.
(_Fwd_list_iterator<>::_M_node): Use _Node_base::_Pointer.
(_Fwd_list_base<>::_M_get_node, _M_create_node, _M_create_node,
_M_insert_after, _M_put_node, _M_erase_after): Likewise.
(_Fwd_list_const_iterator<>::_M_node): use _Node_base::_Const_pointer.
(forward_list<>): Use __static_pointer_cast in place of static_cast,
and __const_pointer_cast in place of const_cast.
* include/bits/forward_list.tcc
(_Fwd_list_node<>::_M_sort_after): Using _Pointer typedefs in place
of standard pointers, __static_pointer_cast in place of static_cast.
(_Fwd_list_base<>::_Fwd_list_base, _M_insert_after, _M_erase_after):
Likewise.
(forward_list<>::_M_initialize_dispatch, _M_fill_initialize,
splice_after, remove, remove_if, merge): Likewise.
* testsuite/23_containers/forward_list/ext_pointer/modifiers/1.cc: New.
* testsuite/23_containers/forward_list/ext_pointer/modifiers/2.cc:
Likewise.
* testsuite/23_containers/forward_list/ext_pointer/modifiers/3.cc:
Likewise.
* testsuite/23_containers/forward_list/ext_pointer/modifiers/4.cc:
Likewise.
* testsuite/23_containers/forward_list/ext_pointer/modifiers/5.cc:
Likewise.
* testsuite/23_containers/forward_list/ext_pointer/operations/1.cc:
Likewise.
* testsuite/23_containers/forward_list/ext_pointer/operations/2.cc:
Likewise.
* testsuite/23_containers/forward_list/ext_pointer/operations/3.cc:
Likewise.
* testsuite/23_containers/forward_list/ext_pointer/operations/4.cc:
Likewise.
* testsuite/23_containers/forward_list/ext_pointer/operations/5.cc:
Likewise.
* testsuite/23_containers/forward_list/ext_pointer/operations/6.cc:
Likewise.
* testsuite/23_containers/forward_list/ext_pointer/operations/7.cc:
Likewise.
* testsuite/23_containers/forward_list/ext_pointer/requirements/1.cc:
Likewise.
* testsuite/23_containers/forward_list/ext_pointer/requirements/
explicit_instantiation/1.cc: Likewise.
* testsuite/23_containers/forward_list/ext_pointer/requirements/
explicit_instantiation/3.cc: Likewise.
* testsuite/23_containers/forward_list/ext_pointer/1.cc: Likewise.
2010-03-13 Paolo Carlini <paolo.carlini@oracle.com>
* include/tr1_impl/array (swap(array<>&, array<>&)): Use member swap.

224
libstdc++-v3/include/bits/forward_list.h
View File

@ -33,59 +33,76 @@
#include <memory>
#include <initializer_list>
#include <ext/cast.h>
_GLIBCXX_BEGIN_NAMESPACE(std)
using __gnu_cxx::__static_pointer_cast;
using __gnu_cxx::__const_pointer_cast;
/**
* @brief A helper basic node class for %forward_list.
* This is just a linked list with nothing inside it.
* There are purely list shuffling utility methods here.
*/
template<typename _Alloc>
struct _Fwd_list_node_base
struct _Fwd_list_node_base
{
_Fwd_list_node_base() : _M_next(0) { }
_Fwd_list_node_base* _M_next;
static void
swap(_Fwd_list_node_base& __x, _Fwd_list_node_base& __y)
{ std::swap(__x._M_next, __y._M_next); }
void
_M_transfer_after(_Fwd_list_node_base* __bbegin)
{
// The type allocated by _Alloc cannot be this type, so we rebind
typedef typename _Alloc::template rebind<_Fwd_list_node_base<_Alloc> >
::other::pointer _Pointer;
typedef typename _Alloc::template rebind<_Fwd_list_node_base<_Alloc> >
::other::const_pointer _Const_pointer;
_Fwd_list_node_base* __bend = __bbegin;
while (__bend && __bend->_M_next)
__bend = __bend->_M_next;
_M_transfer_after(__bbegin, __bend);
}
_Pointer _M_next;
void
_M_transfer_after(_Fwd_list_node_base* __bbegin,
_Fwd_list_node_base* __bend)
{
_Fwd_list_node_base* __keep = __bbegin->_M_next;
if (__bend)
{
__bbegin->_M_next = __bend->_M_next;
__bend->_M_next = _M_next;
}
else
__bbegin->_M_next = 0;
_M_next = __keep;
}
_Fwd_list_node_base() : _M_next(0) { }
static void
swap(_Fwd_list_node_base& __x, _Fwd_list_node_base& __y)
{ std::swap(__x._M_next, __y._M_next); }
void
_M_transfer_after(_Pointer __bbegin);
void
_M_transfer_after(_Pointer __bbegin, _Pointer __bend);
void
_M_reverse_after();
};
void
_M_reverse_after()
{
_Fwd_list_node_base* __tail = _M_next;
if (!__tail)
return;
while (_Fwd_list_node_base* __temp = __tail->_M_next)
{
_Fwd_list_node_base* __keep = _M_next;
_M_next = __temp;
__tail->_M_next = __temp->_M_next;
_M_next->_M_next = __keep;
}
}
};
/**
* @brief A helper node class for %forward_list.
* This is just a linked list with a data value in each node.
* There is a sorting utility method.
*/
template<typename _Tp, typename _Alloc>
struct _Fwd_list_node : public _Fwd_list_node_base<_Alloc>
template<typename _Tp>
struct _Fwd_list_node
: public _Fwd_list_node_base
{
typedef typename _Alloc::template rebind<_Fwd_list_node<_Tp, _Alloc> >
::other::pointer _Pointer;
template<typename... _Args>
_Fwd_list_node(_Args&&... __args)
: _Fwd_list_node_base<_Alloc>(),
: _Fwd_list_node_base(),
_M_value(std::forward<_Args>(__args)...) { }
_Tp _M_value;
@ -96,32 +113,32 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
*
* All the functions are op overloads.
*/
template<typename _Tp, typename _Alloc>
template<typename _Tp>
struct _Fwd_list_iterator
{
typedef _Fwd_list_iterator<_Tp, _Alloc> _Self;
typedef _Fwd_list_node<_Tp, _Alloc> _Node;
typedef _Fwd_list_node_base<_Alloc> _Node_base;
typedef _Fwd_list_iterator<_Tp> _Self;
typedef _Fwd_list_node<_Tp> _Node;
typedef _Tp value_type;
typedef typename _Alloc::pointer pointer;
typedef typename _Alloc::reference reference;
typedef typename _Alloc::difference_type difference_type;
typedef std::forward_iterator_tag iterator_category;
typedef _Tp value_type;
typedef _Tp* pointer;
typedef _Tp& reference;
typedef ptrdiff_t difference_type;
typedef std::forward_iterator_tag iterator_category;
_Fwd_list_iterator() : _M_node() { }
_Fwd_list_iterator()
: _M_node() { }
explicit
_Fwd_list_iterator(typename _Node_base::_Pointer __n)
_Fwd_list_iterator(_Fwd_list_node_base* __n)
: _M_node(__n) { }
reference
operator*() const
{ return __static_pointer_cast<_Node*>(_M_node)->_M_value; }
{ return static_cast<_Node*>(this->_M_node)->_M_value; }
pointer
operator->() const
{ return &__static_pointer_cast<_Node*>(_M_node)->_M_value; }
{ return &static_cast<_Node*>(this->_M_node)->_M_value; }
_Self&
operator++()
@ -155,7 +172,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
return _Fwd_list_iterator(0);
}
typename _Node_base::_Pointer _M_node;
_Fwd_list_node_base* _M_node;
};
/**
@ -163,24 +180,24 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
*
* All the functions are op overloads.
*/
template<typename _Tp, typename _Alloc>
template<typename _Tp>
struct _Fwd_list_const_iterator
{
typedef _Fwd_list_const_iterator<_Tp, _Alloc> _Self;
typedef const _Fwd_list_node<_Tp, _Alloc> _Node;
typedef const _Fwd_list_node_base<_Alloc> _Node_base;
typedef _Fwd_list_iterator<_Tp, _Alloc> iterator;
typedef _Fwd_list_const_iterator<_Tp> _Self;
typedef const _Fwd_list_node<_Tp> _Node;
typedef _Fwd_list_iterator<_Tp> iterator;
typedef _Tp value_type;
typedef typename _Alloc::const_pointer pointer;
typedef typename _Alloc::const_reference reference;
typedef typename _Alloc::difference_type difference_type;
typedef std::forward_iterator_tag iterator_category;
typedef _Tp value_type;
typedef const _Tp* pointer;
typedef const _Tp& reference;
typedef ptrdiff_t difference_type;
typedef std::forward_iterator_tag iterator_category;
_Fwd_list_const_iterator() : _M_node() { }
_Fwd_list_const_iterator()
: _M_node() { }
explicit
_Fwd_list_const_iterator(typename _Node_base::_Const_pointer __n)
_Fwd_list_const_iterator(const _Fwd_list_node_base* __n)
: _M_node(__n) { }
_Fwd_list_const_iterator(const iterator& __iter)
@ -188,11 +205,11 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
reference
operator*() const
{ return __static_pointer_cast<_Node*>(_M_node)->_M_value; }
{ return static_cast<_Node*>(this->_M_node)->_M_value; }
pointer
operator->() const
{ return &__static_pointer_cast<_Node*>(_M_node)->_M_value; }
{ return &static_cast<_Node*>(this->_M_node)->_M_value; }
_Self&
operator++()
@ -226,25 +243,25 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
return _Fwd_list_const_iterator(0);
}
typename _Node_base::_Const_pointer _M_node;
const _Fwd_list_node_base* _M_node;
};
/**
* @brief Forward list iterator equality comparison.
*/
template<typename _Tp, typename _Alloc>
template<typename _Tp>
inline bool
operator==(const _Fwd_list_iterator<_Tp, _Alloc>& __x,
const _Fwd_list_const_iterator<_Tp, _Alloc>& __y)
operator==(const _Fwd_list_iterator<_Tp>& __x,
const _Fwd_list_const_iterator<_Tp>& __y)
{ return __x._M_node == __y._M_node; }
/**
* @brief Forward list iterator inequality comparison.
*/
template<typename _Tp, typename _Alloc>
template<typename _Tp>
inline bool
operator!=(const _Fwd_list_iterator<_Tp, _Alloc>& __x,
const _Fwd_list_const_iterator<_Tp, _Alloc>& __y)
operator!=(const _Fwd_list_iterator<_Tp>& __x,
const _Fwd_list_const_iterator<_Tp>& __y)
{ return __x._M_node != __y._M_node; }
/**
@ -257,12 +274,12 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
typedef typename _Alloc::template
rebind<_Fwd_list_node<_Tp, _Tp_alloc_type>>::other _Node_alloc_type;
rebind<_Fwd_list_node<_Tp>>::other _Node_alloc_type;
struct _Fwd_list_impl
: public _Node_alloc_type
{
_Fwd_list_node_base<_Tp_alloc_type> _M_head;
_Fwd_list_node_base _M_head;
_Fwd_list_impl()
: _Node_alloc_type(), _M_head()
@ -276,11 +293,9 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
_Fwd_list_impl _M_impl;
public:
typedef _Fwd_list_iterator<_Tp, _Tp_alloc_type> iterator;
typedef _Fwd_list_const_iterator<_Tp, _Tp_alloc_type> const_iterator;
typedef _Fwd_list_node<_Tp, _Tp_alloc_type> _Node;
typedef _Fwd_list_node_base<_Tp_alloc_type> _Node_base;
typedef _Fwd_list_iterator<_Tp> iterator;
typedef _Fwd_list_const_iterator<_Tp> const_iterator;
typedef _Fwd_list_node<_Tp> _Node;
_Node_alloc_type&
_M_get_Node_allocator()
@ -302,28 +317,28 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
_Fwd_list_base(_Fwd_list_base&& __lst, const _Alloc& __a)
: _M_impl(__a)
{ _Node_base::swap(this->_M_impl._M_head,
__lst._M_impl._M_head); }
{ _Fwd_list_node_base::swap(this->_M_impl._M_head,
__lst._M_impl._M_head); }
_Fwd_list_base(_Fwd_list_base&& __lst)
: _M_impl(__lst._M_get_Node_allocator())
{ _Node_base::swap(this->_M_impl._M_head,
__lst._M_impl._M_head); }
{ _Fwd_list_node_base::swap(this->_M_impl._M_head,
__lst._M_impl._M_head); }
~_Fwd_list_base()
{ _M_erase_after(&_M_impl._M_head, 0); }
protected:
typename _Node::_Pointer
_Node*
_M_get_node()
{ return _M_get_Node_allocator().allocate(1); }
template<typename... _Args>
typename _Node::_Pointer
_Node*
_M_create_node(_Args&&... __args)
{
typename _Node::_Pointer __node = this->_M_get_node();
_Node* __node = this->_M_get_node();
__try
{
_M_get_Node_allocator().construct(__node,
@ -339,19 +354,19 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
}
template<typename... _Args>
typename _Node_base::_Pointer
_Fwd_list_node_base*
_M_insert_after(const_iterator __pos, _Args&&... __args);
void
_M_put_node(typename _Node::_Pointer __p)
_M_put_node(_Node* __p)
{ _M_get_Node_allocator().deallocate(__p, 1); }
void
_M_erase_after(typename _Node_base::_Pointer __pos);
_M_erase_after(_Fwd_list_node_base* __pos);
void
_M_erase_after(typename _Node_base::_Pointer __pos,
typename _Node_base::_Pointer __last);
_M_erase_after(_Fwd_list_node_base* __pos,
_Fwd_list_node_base* __last);
};
/**
@ -390,8 +405,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
{
private:
typedef _Fwd_list_base<_Tp, _Alloc> _Base;
typedef typename _Base::_Node _Node;
typedef typename _Base::_Node_base _Node_base;
typedef _Fwd_list_node<_Tp> _Node;
typedef _Fwd_list_node_base _Node_base;
typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
public:
@ -402,8 +417,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
typedef typename _Tp_alloc_type::reference reference;
typedef typename _Tp_alloc_type::const_reference const_reference;
typedef typename _Base::iterator iterator;
typedef typename _Base::const_iterator const_iterator;
typedef _Fwd_list_iterator<_Tp> iterator;
typedef _Fwd_list_const_iterator<_Tp> const_iterator;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
typedef _Alloc allocator_type;
@ -731,8 +746,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
reference
front()
{
_Node* __front =
__static_pointer_cast<_Node*>(this->_M_impl._M_head._M_next);
_Node* __front = static_cast<_Node*>(this->_M_impl._M_head._M_next);
return __front->_M_value;
}
@ -743,8 +757,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
const_reference
front() const
{
_Node* __front =
__static_pointer_cast<_Node*>(this->_M_impl._M_head._M_next);
_Node* __front = static_cast<_Node*>(this->_M_impl._M_head._M_next);
return __front->_M_value;
}
@ -865,8 +878,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
{
forward_list __tmp(__n, __val, this->_M_get_Node_allocator());
splice_after(__pos, std::move(__tmp));
return iterator(__const_pointer_cast<typename _Node_base::_Pointer>
(__pos._M_node));
return iterator(const_cast<_Node_base*>(__pos._M_node));
}
/**
@ -890,8 +902,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
{
forward_list __tmp(__first, __last, this->_M_get_Node_allocator());
splice_after(__pos, std::move(__tmp));
return iterator(__const_pointer_cast<typename _Node_base::_Pointer>
(__pos._M_node));
return iterator(const_cast<_Node_base*>(__pos._M_node));
}
/**
@ -913,8 +924,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
{
forward_list __tmp(__il, this->_M_get_Node_allocator());
splice_after(__pos, std::move(__tmp));
return iterator(__const_pointer_cast<typename _Node_base::_Pointer>
(__pos._M_node));
return iterator(const_cast<_Node_base*>(__pos._M_node));
}
/**
@ -934,10 +944,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
*/
void
erase_after(const_iterator __pos)
{
_Node_base* __tmp = __const_pointer_cast<_Node_base*>(__pos._M_node);
this->_M_erase_after(__tmp);
}
{ this->_M_erase_after(const_cast<_Node_base*>(__pos._M_node)); }
/**
* @brief Remove a range of elements.
@ -958,11 +965,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
*/
void
erase_after(const_iterator __pos, const_iterator __last)
{
_Node_base* __tmpp = __const_pointer_cast<_Node_base*>(__pos._M_node);
_Node_base* __tmpl = __const_pointer_cast<_Node_base*>(__last._M_node);
this->_M_erase_after(__tmpp, __tmpl);
}
{ this->_M_erase_after(const_cast<_Node_base*>(__pos._M_node),
const_cast<_Node_base*>(__last._M_node)); }
/**
* @brief Swaps data with another %forward_list.

159
libstdc++-v3/include/bits/forward_list.tcc
View File

@ -31,94 +31,43 @@
_GLIBCXX_BEGIN_NAMESPACE(std)
template<typename _Alloc>
void
_Fwd_list_node_base<_Alloc>::
_M_transfer_after(_Pointer __bbegin)
{
_Pointer __bend = __bbegin;
while (__bend && __bend->_M_next)
__bend = __bend->_M_next;
_M_transfer_after(__bbegin, __bend);
}
template<typename _Alloc>
void
_Fwd_list_node_base<_Alloc>::
_M_transfer_after(_Pointer __bbegin, _Pointer __bend)
{
_Pointer __keep = __bbegin->_M_next;
if (__bend)
{
__bbegin->_M_next = __bend->_M_next;
__bend->_M_next = _M_next;
}
else
__bbegin->_M_next = 0;
_M_next = __keep;
}
template<typename _Alloc>
void
_Fwd_list_node_base<_Alloc>::
_M_reverse_after()
{
_Pointer __tail = _M_next;
if (!__tail)
return;
while (_Pointer __temp = __tail->_M_next)
{
_Pointer __keep = _M_next;
_M_next = __temp;
__tail->_M_next = __temp->_M_next;
_M_next->_M_next = __keep;
}
}
template<typename _Tp, typename _Alloc>
_Fwd_list_base<_Tp, _Alloc>::
_Fwd_list_base(const _Fwd_list_base& __lst, const _Alloc& __a)
: _M_impl(__a)
{
this->_M_impl._M_head._M_next = 0;
typename _Node_base::_Pointer __to = &this->_M_impl._M_head;
typename _Node::_Pointer __curr
= __static_pointer_cast<typename _Node::_Pointer>
(__lst._M_impl._M_head._M_next);
_Fwd_list_node_base* __to = &this->_M_impl._M_head;
_Node* __curr = static_cast<_Node*>(__lst._M_impl._M_head._M_next);
while (__curr)
{
__to->_M_next = _M_create_node(__curr->_M_value);
__to = __to->_M_next;
__curr = __static_pointer_cast<typename _Node::_Pointer>
(__curr->_M_next);
__curr = static_cast<_Node*>(__curr->_M_next);
}
}
template<typename _Tp, typename _Alloc>
template<typename... _Args>
typename _Fwd_list_base<_Tp, _Alloc>::_Node_base::_Pointer
_Fwd_list_node_base*
_Fwd_list_base<_Tp, _Alloc>::
_M_insert_after(const_iterator __pos, _Args&&... __args)
{
typename _Node_base::_Pointer __to
= __const_pointer_cast<typename _Node_base::_Pointer>
(__pos._M_node);
typename _Node::_Pointer __thing
= __static_pointer_cast<typename _Node::_Pointer>(
_M_create_node(std::forward<_Args>(__args)...) );
_Fwd_list_node_base* __to
= const_cast<_Fwd_list_node_base*>(__pos._M_node);
_Node* __thing = _M_create_node(std::forward<_Args>(__args)...);
__thing->_M_next = __to->_M_next;
__to->_M_next = __thing;
return __static_pointer_cast<typename _Node_base::_Pointer>
(__to->_M_next);
return __to->_M_next;
}
template<typename _Tp, typename _Alloc>
void
_Fwd_list_base<_Tp, _Alloc>::
_M_erase_after(typename _Node_base::_Pointer __pos)
_M_erase_after(_Fwd_list_node_base* __pos)
{
typename _Node::_Pointer __curr
= __static_pointer_cast<typename _Node::_Pointer>(__pos->_M_next);
_Node* __curr = static_cast<_Node*>(__pos->_M_next);
__pos->_M_next = __curr->_M_next;
_M_get_Node_allocator().destroy(__curr);
_M_put_node(__curr);
@ -127,16 +76,14 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
template<typename _Tp, typename _Alloc>
void
_Fwd_list_base<_Tp, _Alloc>::
_M_erase_after(typename _Node_base::_Pointer __pos,
typename _Node_base::_Pointer __last)
_M_erase_after(_Fwd_list_node_base* __pos,
_Fwd_list_node_base* __last)
{
typename _Node::_Pointer __curr
= __static_pointer_cast<typename _Node::_Pointer>(__pos->_M_next);
_Node* __curr = static_cast<_Node*>(__pos->_M_next);
while (__curr != __last)
{
typename _Node::_Pointer __temp = __curr;
__curr = __static_pointer_cast<typename _Node::_Pointer>
(__curr->_M_next);
_Node* __temp = __curr;
__curr = static_cast<_Node*>(__curr->_M_next);
_M_get_Node_allocator().destroy(__temp);
_M_put_node(__temp);
}
@ -151,7 +98,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
{
typename _Node_base::_Pointer __to = &this->_M_impl._M_head;
_Node_base* __to = &this->_M_impl._M_head;
for (; __first != __last; ++__first)
{
__to->_M_next = this->_M_create_node(*__first);
@ -166,7 +113,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
forward_list<_Tp, _Alloc>::
_M_fill_initialize(size_type __n, const value_type& __value)
{
typename _Node_base::_Pointer __to = &this->_M_impl._M_head;
_Node_base* __to = &this->_M_impl._M_head;
for (; __n > 0; --__n)
{
__to->_M_next = this->_M_create_node(__value);
@ -179,7 +126,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
forward_list(size_type __n)
: _Base()
{
typename _Node_base::_Pointer __to = &this->_M_impl._M_head;
_Node_base* __to = &this->_M_impl._M_head;
for (; __n > 0; --__n)
{
__to->_M_next = this->_M_create_node();
@ -262,13 +209,9 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
{
if (!__list.empty() && &__list != this)
{
typename _Node_base::_Pointer __tmp
= __const_pointer_cast<typename _Node_base::_Pointer>
(__pos._M_node);
_Node_base* __tmp = const_cast<_Node_base*>(__pos._M_node);
const_iterator __before = __list.cbefore_begin();
__tmp->_M_transfer_after(__const_pointer_cast
<typename _Node_base::_Pointer>
(__before._M_node));
__tmp->_M_transfer_after(const_cast<_Node_base*>(__before._M_node));
}
}
@ -278,14 +221,9 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
splice_after(const_iterator __pos, forward_list&& __list,
const_iterator __before, const_iterator __last)
{
typename _Node_base::_Pointer __tmp
= __const_pointer_cast<typename _Node_base::_Pointer>(__pos._M_node);
__tmp->_M_transfer_after(__const_pointer_cast
<typename _Node_base::_Pointer>
(__before._M_node),
__const_pointer_cast
<typename _Node_base::_Pointer>
(__last._M_node));
_Node_base* __tmp = const_cast<_Node_base*>(__pos._M_node);
__tmp->_M_transfer_after(const_cast<_Node_base*>(__before._M_node),
const_cast<_Node_base*>(__last._M_node));
}
template<typename _Tp, typename _Alloc>
@ -293,17 +231,13 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
forward_list<_Tp, _Alloc>::
remove(const _Tp& __val)
{
typename _Node::_Pointer __curr
= __static_pointer_cast<typename _Node::_Pointer>
(&this->_M_impl._M_head);
while (typename _Node::_Pointer __temp =
__static_pointer_cast<typename _Node::_Pointer>(__curr->_M_next))
_Node* __curr = static_cast<_Node*>(&this->_M_impl._M_head);
while (_Node* __temp = static_cast<_Node*>(__curr->_M_next))
{
if (__temp->_M_value == __val)
this->_M_erase_after(__curr);
else
__curr = __static_pointer_cast<typename _Node::_Pointer>
(__curr->_M_next);
__curr = static_cast<_Node*>(__curr->_M_next);
}
}
@ -313,17 +247,13 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
forward_list<_Tp, _Alloc>::
remove_if(_Pred __pred)
{
typename _Node::_Pointer __curr
= __static_pointer_cast<typename _Node::_Pointer>
(&this->_M_impl._M_head);
while (typename _Node::_Pointer __temp =
__static_pointer_cast<typename _Node::_Pointer>(__curr->_M_next))
_Node* __curr = static_cast<_Node*>(&this->_M_impl._M_head);
while (_Node* __temp = static_cast<_Node*>(__curr->_M_next))
{
if (__pred(__temp->_M_value))
this->_M_erase_after(__curr);
else
__curr = __static_pointer_cast<typename _Node::_Pointer>
(__curr->_M_next);
__curr = static_cast<_Node*>(__curr->_M_next);
}
}
@ -354,12 +284,12 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
forward_list<_Tp, _Alloc>::
merge(forward_list&& __list, _Comp __comp)
{
typename _Node_base::_Pointer __node = &this->_M_impl._M_head;
_Node_base* __node = &this->_M_impl._M_head;
while (__node->_M_next && __list._M_impl._M_head._M_next)
{
if (__comp(__static_pointer_cast<typename _Node::_Pointer>
if (__comp(static_cast<_Node*>
(__list._M_impl._M_head._M_next)->_M_value,
__static_pointer_cast<typename _Node::_Pointer>
static_cast<_Node*>
(__node->_M_next)->_M_value))
__node->_M_transfer_after(&__list._M_impl._M_head,
__list._M_impl._M_head._M_next);
@ -400,11 +330,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
forward_list<_Tp, _Alloc>::
sort(_Comp __comp)
{
typedef typename _Node::_Pointer _Pointer;
// If `next' is 0, return immediately.
_Pointer __list =
__static_pointer_cast<_Pointer>(this->_M_impl._M_head._M_next);
_Node* __list = static_cast<_Node*>(this->_M_impl._M_head._M_next);
if (!__list)
return;
@ -412,9 +339,9 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
while (1)
{
_Pointer __p = __list;
_Node* __p = __list;
__list = 0;
_Pointer __tail = 0;
_Node* __tail = 0;
// Count number of merges we do in this pass.
unsigned long __nmerges = 0;
@ -424,12 +351,12 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
++__nmerges;
// There exists a merge to be done.
// Step `insize' places along from p.
_Pointer __q = __p;
_Node* __q = __p;
unsigned long __psize = 0;
for (unsigned long __i = 0; __i < __insize; ++__i)
{
++__psize;
__q = __static_pointer_cast<_Pointer>(__q->_M_next);
__q = static_cast<_Node*>(__q->_M_next);
if (!__q)
break;
}
@ -441,33 +368,33 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
while (__psize > 0 || (__qsize > 0 && __q))
{
// Decide whether next node of merge comes from p or q.
_Pointer __e;
_Node* __e;
if (__psize == 0)
{
// p is empty; e must come from q.
__e = __q;
__q = __static_pointer_cast<_Pointer>(__q->_M_next);
__q = static_cast<_Node*>(__q->_M_next);
--__qsize;
}
else if (__qsize == 0 || !__q)
{
// q is empty; e must come from p.
__e = __p;
__p = __static_pointer_cast<_Pointer>(__p->_M_next);
__p = static_cast<_Node*>(__p->_M_next);
--__psize;
}
else if (__comp(__p->_M_value, __q->_M_value))
{
// First node of p is lower; e must come from p.
__e = __p;
__p = __static_pointer_cast<_Pointer>(__p->_M_next);
__p = static_cast<_Node*>(__p->_M_next);
--__psize;
}
else
{
// First node of q is lower; e must come from q.
__e = __q;
__q = __static_pointer_cast<_Pointer>(__q->_M_next);
__q = static_cast<_Node*>(__q->_M_next);
--__qsize;
}

5
libstdc++-v3/testsuite/23_containers/forward_list/capacity/1.cc
View File

@ -1,6 +1,6 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
// Copyright (C) 2008, 2009, 2010 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
@ -39,8 +39,7 @@ test01()
VERIFY(fld.empty() == true);
VERIFY( (fld.max_size()
== std::allocator<std::_Fwd_list_node<double,
std::allocator<double> > >().max_size()) );
== std::allocator<std::_Fwd_list_node<double> >().max_size()) );
}
int

98
libstdc++-v3/testsuite/23_containers/forward_list/ext_pointer/1.cc
View File

@ -1,98 +0,0 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009 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 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 23.2.3.n forward_list capacity [lib.forward_list.capacity]
#include <forward_list>
#include <ext/extptr_allocator.h>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
using __gnu_cxx::_ExtPtr_allocator;
// This test verifies the following.
//
void
test01()
{
std::forward_list<double, _ExtPtr_allocator<double> > fld;
VERIFY(fld.empty() == true);
fld.push_front(1.0);
VERIFY(fld.empty() == false);
fld.resize(0);
VERIFY(fld.empty() == true);
}
void
test02()
{
std::forward_list<int, _ExtPtr_allocator<int> > a, b;
a.push_front(1);
b = std::move(a);
VERIFY(b.empty() == false);
VERIFY(*b.begin() == 1);
VERIFY(a.empty() == true);
std::forward_list<int, _ExtPtr_allocator<int> > c(std::move(b));
VERIFY(c.empty() == false);
(*c.begin() == 1 );
VERIFY( b.empty() == true );
}
// Test various constrcutors
void
test03()
{
const int ni = 10;
int i[ni] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
_ExtPtr_allocator<int> alloc;
std::forward_list<int, _ExtPtr_allocator<int> > flccin(i, i+ni);
std::forward_list<int, _ExtPtr_allocator<int> > flc(flccin);
std::forward_list<int, _ExtPtr_allocator<int> > flm(std::move(flccin));
std::forward_list<int, _ExtPtr_allocator<int> > flcc(flccin, alloc );
std::forward_list<int, _ExtPtr_allocator<int> > flmc(
std::forward_list<int, _ExtPtr_allocator<int> >(i, i+ni), alloc);
std::forward_list<double, _ExtPtr_allocator<double> > flil(
{1.0, 2.0, 3.0, 4.0, 5.0});
}
// Test constrcutors
// Construction from given number of default item
// Construction from given number of given item
void
test04()
{
std::forward_list<double, _ExtPtr_allocator<double> > flvd(10);
std::forward_list<float, _ExtPtr_allocator<float> > flv(10, 5.0F);
}
int
main()
{
test01();
test02();
test03();
test04();
return 0;
}

75
libstdc++-v3/testsuite/23_containers/forward_list/ext_pointer/modifiers/1.cc
View File

@ -1,75 +0,0 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009 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 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <ext/extptr_allocator.h>
#include <testsuite_hooks.h>
#include <array>
bool test __attribute__((unused)) = true;
using __gnu_cxx::_ExtPtr_allocator;
class PathPoint
{
public:
PathPoint(char t, std::array<double, 3> & c)
: type(t), coord(c) { }
char getType() const { return type; }
private:
char type;
std::array<double, 3> coord;
};
// This test verifies the following.
// emplace_front
// pop_front
// emplace_after
void
test01()
{
std::forward_list<PathPoint, _ExtPtr_allocator<PathPoint> > path;
std::array<double, 3> coord1 = { { 0.0, 1.0, 2.0 } };
path.emplace_front('a', coord1);
std::forward_list<PathPoint, _ExtPtr_allocator<PathPoint> >::const_iterator pos = path.cbegin();
std::array<double, 3> coord2 = { { 3.0, 4.0, 5.0 } };
path.emplace_after(pos, 'b', coord2);
VERIFY(path.front().getType() == 'a');
path.pop_front();
VERIFY(path.front().getType() == 'b');
path.pop_front();
VERIFY(path.empty() == true);
}
int
main()
{
test01();
return 0;
}

160
libstdc++-v3/testsuite/23_containers/forward_list/ext_pointer/modifiers/2.cc
View File

@ -1,160 +0,0 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009, 2010 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 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <ext/extptr_allocator.h>
#include <testsuite_hooks.h>
#include <string>
bool test __attribute__((unused)) = true;
using __gnu_cxx::_ExtPtr_allocator;
// This test verifies the following:
// insert_after single item
// before_begin iterator
void
test01()
{
std::forward_list<int, _ExtPtr_allocator<int> > fl(
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
std::forward_list<int, _ExtPtr_allocator<int> >::iterator ret
= fl.insert_after(fl.before_begin(), 42);
VERIFY(ret == fl.begin());
VERIFY(fl.front() == 42);
}
// This test verifies the following:
void
test02()
{
std::forward_list<int, _ExtPtr_allocator<int> > fl(
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
std::forward_list<int, _ExtPtr_allocator<int> >::const_iterator pos
= fl.cbegin();
++pos;
VERIFY(*pos == 1);
// Note: Calling l.insert_after(pos, 5, 42); without the long five
// gets resolved to the iterator range version and fails to compile!
std::forward_list<int, _ExtPtr_allocator<int> >::iterator ret
= fl.insert_after(pos, 5, 42);
VERIFY(ret == pos);
VERIFY(*pos == 1);
++pos;
VERIFY(*pos == 42);
++pos;
++pos;
++pos;
++pos;
VERIFY(*pos == 42);
}
// This test verifies the following:
void
test03()
{
std::forward_list<int, _ExtPtr_allocator<int> > fl(
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
std::forward_list<int, _ExtPtr_allocator<int> >::const_iterator pos
= fl.cbegin();
++pos;
VERIFY(*pos == 1);
int i[3] = {666, 777, 888};
std::forward_list<int, _ExtPtr_allocator<int> >::iterator ret
= fl.insert_after(pos, i, i + 3);
VERIFY(ret == pos);
VERIFY(*pos == 1);
++pos;
++pos;
++pos;
VERIFY(*pos == 888);
++pos;
VERIFY(*pos == 2);
}
// This test verifies the following:
void
test04()
{
std::forward_list<int, _ExtPtr_allocator<int> > fl(
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
std::forward_list<int, _ExtPtr_allocator<int> >::const_iterator
pos = fl.cbegin();
++pos;
VERIFY(*pos == 1);
std::forward_list<int, _ExtPtr_allocator<int> >::iterator ret
= fl.insert_after(pos, {-1, -2, -3, -4, -5});
VERIFY(ret == pos);
VERIFY(*pos == 1);
++pos;
++pos;
++pos;
VERIFY(*pos == -3);
}
// This test verifies the following:
void
test05()
{
std::forward_list<std::string, _ExtPtr_allocator<std::string> > fl(
{"AAA", "BBB", "CCC"});
std::forward_list<std::string, _ExtPtr_allocator<std::string> >::
const_iterator pos = fl.cbegin();
++pos;
VERIFY(*pos == "BBB");
std::string x( "XXX" );
std::forward_list<std::string, _ExtPtr_allocator<std::string> >::iterator ret
= fl.insert_after(pos, std::move(x));
VERIFY(*pos == "BBB");
++pos;
VERIFY(ret == pos);
VERIFY(*pos == "XXX");
++pos;
VERIFY(*pos == "CCC");
}
int
main()
{
test01();
test02();
test03();
test04();
test05();
return 0;
}

100
libstdc++-v3/testsuite/23_containers/forward_list/ext_pointer/modifiers/3.cc
View File

@ -1,100 +0,0 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009 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 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <ext/extptr_allocator.h>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
using __gnu_cxx::_ExtPtr_allocator;
// This test verifies the following:
// cbegin
// erase_after one iterator
// pos is useable and points to current element
void
test01()
{
std::forward_list<int, _ExtPtr_allocator<int> > fl(
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
std::forward_list<int, _ExtPtr_allocator<int> >::const_iterator
pos = fl.cbegin();
++pos;
VERIFY(*pos == 1);
fl.erase_after(pos);
VERIFY(*pos == 1);
++pos;
VERIFY(*pos == 3);
}
// This test verifies the following:
// cbegin
// erase_after iterator range
// pos is useable and points to current element
void
test02()
{
std::forward_list<int, _ExtPtr_allocator<int> > fl(
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
std::forward_list<int, _ExtPtr_allocator<int> >::const_iterator
pos = fl.cbegin();
++pos;
VERIFY(*pos == 1);
std::forward_list<int, _ExtPtr_allocator<int> >::iterator
stop = fl.begin();
++stop;
++stop;
++stop;
++stop;
VERIFY(*stop == 4);
fl.erase_after(pos, stop);
VERIFY(*pos == 1);
++pos;
VERIFY(*pos == 4);
VERIFY(std::distance(fl.begin(), fl.end()) == 8);
fl.erase_after(pos, fl.end());
VERIFY(++pos == fl.end());
VERIFY(std::distance(fl.begin(), fl.end()) == 3);
fl.erase_after(fl.before_begin(), pos);
VERIFY(std::distance(fl.begin(), fl.end()) == 0);
VERIFY(fl.empty());
}
int
main()
{
test01();
test02();
return 0;
}

48
libstdc++-v3/testsuite/23_containers/forward_list/ext_pointer/modifiers/4.cc
View File

@ -1,48 +0,0 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009 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 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <ext/extptr_allocator.h>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following:
// swap
void
test01()
{
std::forward_list<int> fl1({0, 1, 2, 3, 4, 5});
std::forward_list<int> fl2({666, 777, 888});
fl1.swap(fl2);
VERIFY(fl1.front() == 666);
VERIFY(fl2.front() == 0);
}
int
main()
{
test01();
return 0;
}

48
libstdc++-v3/testsuite/23_containers/forward_list/ext_pointer/modifiers/5.cc
View File

@ -1,48 +0,0 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009 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 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <ext/extptr_allocator.h>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following:
// clear
void
test01()
{
std::forward_list<int, __gnu_cxx::_ExtPtr_allocator<int> > fl(
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
VERIFY(fl.empty() == false);
fl.clear();
VERIFY(fl.empty() == true);
}
int
main()
{
test01();
return 0;
}

115
libstdc++-v3/testsuite/23_containers/forward_list/ext_pointer/operations/1.cc
View File

@ -1,115 +0,0 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009 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 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
#include <ext/extptr_allocator.h>
using __gnu_cxx::_ExtPtr_allocator;
bool test __attribute__((unused)) = true;
// This test verifies the following:
//
void
test01()
{
typedef std::forward_list<double, _ExtPtr_allocator<double> > fwd_list_type;
fwd_list_type a = {0.0, 1.0, 2.0, 3.0, 4.0};
fwd_list_type::const_iterator posa = a.cbefore_begin();
fwd_list_type x = {666.0, 777.0, 888.0};
a.splice_after(posa, std::move(x));
++posa;
VERIFY(*posa == 666.0);
VERIFY(x.empty() == true);
}
// This test verifies the following:
//
void
test02()
{
typedef std::forward_list<double, _ExtPtr_allocator<double> > fwd_list_type;
fwd_list_type a = {0.0, 1.0, 2.0, 3.0, 4.0};
fwd_list_type::const_iterator posa = a.cbefore_begin();
++posa;
VERIFY(*posa == 0.0);
fwd_list_type y = {10.0, 11.0, 12.0, 13.0, 14.0, 15.0};
fwd_list_type::const_iterator befy = y.cbefore_begin();
++befy;
VERIFY(*befy == 10.0);
fwd_list_type::const_iterator endy = befy;
++endy;
++endy;
++endy;
++endy;
VERIFY(*endy == 14.0);
a.splice_after(posa, std::move(y), befy, endy);
VERIFY(*posa == 0.0);
VERIFY(*befy == 10.0);
++befy;
VERIFY(*befy == 15.0);
}
// This test verifies the following:
//
void
test03()
{
typedef std::forward_list<double, _ExtPtr_allocator<double> > fwd_list_type;
fwd_list_type a = {0.0, 1.0, 2.0, 3.0, 4.0};
fwd_list_type::const_iterator posa = a.cbefore_begin();
++posa;
++posa;
VERIFY(*posa == 1.0);
fwd_list_type z = {42.0, 43.0, 44.0};
fwd_list_type::const_iterator posz = z.begin();
VERIFY(*posz == 42.0);
a.splice_after(posa, std::move(z), posz);
VERIFY(*posa == 1.0);
++posa;
VERIFY(*posa == 43.0);
VERIFY(*posz == 42.0);
++posz;
VERIFY(*posz == 44.0);
}
int
main()
{
test01();
test02();
test03();
return 0;
}

56
libstdc++-v3/testsuite/23_containers/forward_list/ext_pointer/operations/2.cc
View File

@ -1,56 +0,0 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009 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 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
#include <ext/extptr_allocator.h>
using __gnu_cxx::_ExtPtr_allocator;
bool test __attribute__((unused)) = true;
// This test verifies the following:
// remove
void
test01()
{
std::forward_list<int, _ExtPtr_allocator<int> > fl =
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
fl.remove(7);
std::forward_list<int, _ExtPtr_allocator<int> >::const_iterator
pos = fl.cbefore_begin();
for (std::size_t i = 0; i < 7; ++i)
++pos;
VERIFY(*pos == 6);
++pos;
VERIFY(*pos == 8);
}
int
main()
{
test01();
return 0;
}

52
libstdc++-v3/testsuite/23_containers/forward_list/ext_pointer/operations/3.cc
View File

@ -1,52 +0,0 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009 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 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
#include <ext/extptr_allocator.h>
#include <algorithm>
bool test __attribute__((unused)) = true;
using __gnu_cxx::_ExtPtr_allocator;
// This test verifies the following:
// remove_if
void
test01()
{
std::forward_list<int, _ExtPtr_allocator<int> > fl =
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
fl.remove_if(std::bind2nd(std::less<int>(),5));
std::forward_list<int, _ExtPtr_allocator<int> >::const_iterator
pos = fl.cbegin();
VERIFY(*pos == 5);
}
int
main()
{
test01();
return 0;
}

85
libstdc++-v3/testsuite/23_containers/forward_list/ext_pointer/operations/4.cc
View File

@ -1,85 +0,0 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009 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 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
#include <ext/extptr_allocator.h>
using __gnu_cxx::_ExtPtr_allocator;
bool test __attribute__((unused)) = true;
// This test verifies the following:
// unique
void
test01()
{
std::forward_list<int, _ExtPtr_allocator<int> > fl =
{99, 5, 99, 6, -5, 666, 777, 888, 42, 42, 42, 42, 42, 7, 0, 0, 0, 9, 9, 9};
fl.unique();
std::forward_list<int, _ExtPtr_allocator<int> > fl2 =
{99, 5, 99, 6, -5, 666, 777, 888, 42, 7, 0, 9};
VERIFY(fl == fl2);
}
// Test comparison predicate.
template<typename Num>
class Mod
{
public:
Mod(const Num & mod)
{
m = mod;
}
bool operator()(const Num i, const Num j)
{
return i%m == j%m;
}
private:
Num m;
};
// This test verifies the following:
// unique with predicate
void
test02()
{
std::forward_list<int, _ExtPtr_allocator<int> > fl =
{99, 5, 99, 6, -5, 666, 777, 888, 42, 7, 0, 9};
fl.unique(Mod<int>(111));
std::forward_list<int, _ExtPtr_allocator<int> > fl2 =
{99, 5, 99, 6, -5, 666, 42, 7, 0, 9};
VERIFY(fl == fl2);
}
int
main()
{
test01();
test02();
return 0;
}

52
libstdc++-v3/testsuite/23_containers/forward_list/ext_pointer/operations/5.cc
View File

@ -1,52 +0,0 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009 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 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
#include <ext/extptr_allocator.h>
using __gnu_cxx::_ExtPtr_allocator;
bool test __attribute__((unused)) = true;
// This test verifies the following:
//
void
test01()
{
typedef std::forward_list<double, _ExtPtr_allocator<double> > fwd_list_type;
fwd_list_type a = {0.0, 1.0, 2.0, 3.0, 4.0};
fwd_list_type b = {1.0, 2.0, 3.0, 4.0, 4.0, 5.0};
a.merge(std::move(b));
fwd_list_type r = {0.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 4.0, 5.0};
VERIFY(a == r);
}
int
main()
{
test01();
return 0;
}

88
libstdc++-v3/testsuite/23_containers/forward_list/ext_pointer/operations/6.cc
View File

@ -1,88 +0,0 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009 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 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
#include <ext/extptr_allocator.h>
using __gnu_cxx::_ExtPtr_allocator;
bool test __attribute__((unused)) = true;
// Comparison functor.
template<typename Num>
class Comp
{
public:
Comp(const Num & num)
{
n = num;
}
bool operator()(const Num i, const Num j)
{
return (n * i) < (n * j);
}
private:
Num n;
};
// This test verifies the following:
//
void
test01()
{
typedef std::forward_list<int, _ExtPtr_allocator<int> > fwd_list_type;
const unsigned int n = 13;
int order[][n] = {
{ 0,1,2,3,4,5,6,7,8,9,10,11,12 },
{ 6,2,8,4,11,1,12,7,3,9,5,0,10 },
{ 12,11,10,9,8,7,6,5,4,3,2,1,0 },
};
fwd_list_type sorted(order[0], order[0] + n);
for (unsigned int i = 0; i < sizeof(order)/sizeof(*order); ++i)
{
fwd_list_type head(order[i], order[i] + n);
head.sort();
VERIFY(head == sorted);
}
fwd_list_type reversed(order[2], order[2] + n);
for (unsigned int i = 0; i < sizeof(order)/sizeof(*order); ++i)
{
fwd_list_type head(order[i], order[i] + n);
Comp<int> comp(-1);
head.sort( comp );
VERIFY(head == reversed);
}
}
int
main()
{
test01();
return 0;
}

57
libstdc++-v3/testsuite/23_containers/forward_list/ext_pointer/operations/7.cc
View File

@ -1,57 +0,0 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009 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 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
#include <ext/extptr_allocator.h>
#include <algorithm>
using __gnu_cxx::_ExtPtr_allocator;
bool test __attribute__((unused)) = true;
// This test verifies the following:
//
void
test01()
{
const unsigned int n = 13;
int order[n] = {0,1,2,3,4,5,6,7,8,9,10,11,12};
std::forward_list<int, _ExtPtr_allocator<int> > fl(order, order + n);
std::forward_list<int, _ExtPtr_allocator<int> > fl2;
for (std::size_t i = 0; i < n; ++i)
fl2.push_front(order[i]);
fl.reverse();
VERIFY(std::lexicographical_compare(fl.begin(), fl.end(),
fl2.begin(), fl2.end()) == false);
}
int
main()
{
test01();
return 0;
}

72
libstdc++-v3/testsuite/23_containers/forward_list/ext_pointer/requirements/1.cc
View File

@ -1,72 +0,0 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009 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 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <ext/extptr_allocator.h>
#include <testsuite_hooks.h>
using __gnu_cxx::_ExtPtr_allocator;
bool test __attribute__((unused)) = true;
// A nontrivial type.
template<typename T>
struct A { };
// Another nontrivial type
struct B { };
// A nontrivial type convertible from an int
struct C
{
C(int i) : i_(i) { }
bool operator==(const C& rhs) { return i_ == rhs.i_; }
int i_;
};
// This test verifies the following.
//
void
test01()
{
std::forward_list< A<B>, _ExtPtr_allocator<A<B> > > lst;
VERIFY(lst.begin() == lst.end());
VERIFY(std::distance(lst.begin(), lst.end()) == 0);
// check type definitions -- will fail compile if missing
typedef std::forward_list< A<B> >::reference reference;
typedef std::forward_list< A<B> >::const_reference const_reference;
typedef std::forward_list< A<B> >::iterator iterator;
typedef std::forward_list< A<B> >::const_iterator const_iterator;
typedef std::forward_list< A<B> >::size_type size_type;
typedef std::forward_list< A<B> >::difference_type difference_type;
typedef std::forward_list< A<B> >::value_type value_type;
typedef std::forward_list< A<B> >::allocator_type allocator_type;
typedef std::forward_list< A<B> >::pointer pointer;
typedef std::forward_list< A<B> >::const_pointer const_pointer;
}
int
main()
{
test01();
return 0;
}

27
libstdc++-v3/testsuite/23_containers/forward_list/ext_pointer/requirements/explicit_instantiation/1.cc
View File

@ -1,27 +0,0 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009 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 3, 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// This file tests explicit instantiation of library containers
#include <forward_list>
#include <ext/extptr_allocator.h>
// { dg-do compile }
template class std::forward_list<int, __gnu_cxx::_ExtPtr_allocator<int> >;

29
libstdc++-v3/testsuite/23_containers/forward_list/ext_pointer/requirements/explicit_instantiation/3.cc
View File

@ -1,29 +0,0 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009 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 3, 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 COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// This file tests explicit instantiation of library containers
#include <forward_list>
#include <ext/extptr_allocator.h>
// { dg-do compile }
// libstdc++/21770
template class std::forward_list<int, __gnu_cxx::_ExtPtr_allocator<char> >;

2
libstdc++-v3/testsuite/23_containers/forward_list/requirements/dr438/assign_neg.cc
View File

@ -1,6 +1,6 @@
// { dg-do compile }
// { dg-options "-std=gnu++0x" }
// { dg-error "no matching" "" { target *-*-* } 1197 }
// { dg-error "no matching" "" { target *-*-* } 1201 }
// { dg-excess-errors "" }
// Copyright (C) 2009, 2010 Free Software Foundation

2
libstdc++-v3/testsuite/23_containers/forward_list/requirements/dr438/constructor_1_neg.cc
View File

@ -1,6 +1,6 @@
// { dg-do compile }
// { dg-options "-std=gnu++0x" }
// { dg-error "no matching" "" { target *-*-* } 1197 }
// { dg-error "no matching" "" { target *-*-* } 1201 }
// { dg-excess-errors "" }
// Copyright (C) 2009, 2010 Free Software Foundation

2
libstdc++-v3/testsuite/23_containers/forward_list/requirements/dr438/constructor_2_neg.cc
View File

@ -1,6 +1,6 @@
// { dg-do compile }
// { dg-options "-std=gnu++0x" }
// { dg-error "no matching" "" { target *-*-* } 1197 }
// { dg-error "no matching" "" { target *-*-* } 1201 }
// { dg-excess-errors "" }
// Copyright (C) 2009, 2010 Free Software Foundation

2
libstdc++-v3/testsuite/23_containers/forward_list/requirements/dr438/insert_neg.cc
View File

@ -1,6 +1,6 @@
// { dg-do compile }
// { dg-options "-std=gnu++0x" }
// { dg-error "no matching" "" { target *-*-* } 1197 }
// { dg-error "no matching" "" { target *-*-* } 1201 }
// { dg-excess-errors "" }
// Copyright (C) 2009, 2010 Free Software Foundation