+2007-10-04 Paolo Carlini <pcarlini@suse.de>
+
+ * testsuite/23_containers/vector/requirements/dr438/assign_neg.cc:
+ Adjust dg-error line number.
+ * testsuite/23_containers/vector/requirements/dr438/insert_neg.cc:
+ Likewise.
+ * testsuite/23_containers/vector/requirements/dr438/
+ constructor_1_neg.cc: Likewise.
+ * testsuite/23_containers/vector/requirements/dr438/
+ constructor_2_neg.cc: Likewise.
+ * testsuite/23_containers/deque/requirements/dr438/assign_neg.cc:
+ Adjust dg-error line number.
+ * testsuite/23_containers/deque/requirements/dr438/insert_neg.cc:
+ Likewise.
+ * testsuite/23_containers/deque/requirements/dr438/
+ constructor_1_neg.cc: Likewise.
+ * testsuite/23_containers/deque/requirements/dr438/
+ constructor_2_neg.cc: Likewise.
+ * testsuite/23_containers/list/requirements/dr438/assign_neg.cc:
+ Adjust dg-error line number.
+ * testsuite/23_containers/list/requirements/dr438/insert_neg.cc:
+ Likewise.
+ * testsuite/23_containers/list/requirements/dr438/
+ constructor_1_neg.cc: Likewise.
+ * testsuite/23_containers/list/requirements/dr438/
+ constructor_2_neg.cc: Likewise.
+
+2007-10-04 Chris Jefferson <chris@bubblescope.net>
+ Paolo Carlini <pcarlini@suse.de>
+
+ * include/bits/stl_list.h (list<>::list(list&&),
+ list<>::operator=(list&&)): Add.
+ (list<>::swap): Adjust.
+ (swap(list&&, list& __y), swap(list&, list&& __y)): Add.
+ * include/bits/stl_vector.h (vector<>::vector(vector&&),
+ vector<>::operator=(vector&&)): Add.
+ (vector<>::swap): Adjust.
+ (swap(vector&&, vector& __y), swap(vector&, vector&& __y)): Add.
+ * include/bits/stl_bvector.h (vector<>::vector(vector&&),
+ vector<>::operator=(vector&&)): Add.
+ (vector<>::swap): Adjust.
+ * include/bits/stl_deque.h (deque<>::deque(deque&&),
+ deque<>::operator=(deque&&)): Add.
+ (deque<>::swap): Adjust.
+ (swap(deque&&, deque& __y), swap(deque&, deque&& __y)): Add.
+ * include/bits/stl_set.h (set<>::set(set&&),
+ set<>::operator=(set&&)): Add.
+ (set<>::swap): Adjust.
+ (swap(set&&, set& __y), swap(set&, set&& __y)): Add.
+ * include/bits/stl_map.h (map<>::map(map&&),
+ map<>::operator=(map&&)): Add.
+ (map<>::swap): Adjust.
+ (swap(map&&, map& __y), swap(map&, map&& __y)): Add.
+ * include/bits/stl_multiset.h (multiset<>::multiset(multiset&&),
+ multiset<>::operator=(multiset&&)): Add.
+ (smultiet<>::swap): Adjust.
+ (swap(multiset&&, multiset& __y),
+ swap(multiset&, multiset&& __y)): Add.
+ * include/bits/stl_multimap.h (multimap<>::multimap(multimap&&),
+ multimap<>::operator=(multimap&&)): Add.
+ (multimap<>::swap): Adjust.
+ (swap(multimap&&, multimap& __y),
+ swap(multimap&, multimap&& __y)): Add.
+
+2007-10-04 Paolo Carlini <pcarlini@suse.de>
+
+ Avoid copying some allocator objects.
+ * include/bits/stl_list.h (_List_impl::_List_impl(),
+ _List_base::_List_base(), list<>::list()): Add.
+ * include/bits/stl_vector.h (_Vector_impl::_Vector_impl(),
+ _Vector_base::_Vector_base(), vector<>::vector()): Add.
+ * include/bits/stl_bvector.h (_Bvector_impl::_Bvector_impl(),
+ _Bvector_base::_Bvector_base(), vector<>::vector()): Add.
+ * include/bits/stl_deque.h (_Deque_impl::_Deque_impl(),
+ _Deque_base::_Deque_base(), deque<>::deque()): Add.
+ * include/bits/stl_tree.h (_Rb_tree_impl<>::_Rb_tree_impl(),
+ _Rb_tree_impl<>::_M_initialize): Add.
+ (_Rb_tree<>::_Rb_tree(const _Compare&, const allocator_type&),
+ _Rb_tree(const _Rb_tree&)): Adjust.
+ * include/bits/stl_set.h (set<>::set(),
+ set(_InputIterator, _InputIterator)): Use _M_t default constructor.
+ * include/bits/stl_map.h (map<>::map(), set(_InputIterator,
+ _InputIterator)): Use _M_t default constructor.
+ * include/bits/stl_multiset.h (multiset<>::multiset(),
+ multiset(_InputIterator, _InputIterator)): Use _M_t default
+ constructor.
+ * include/bits/stl_multimap.h (multimap<>::multimap(),
+ multimap(_InputIterator, _InputIterator)): Use _M_t default
+ constructor.
+
2007-10-03 Chris Jefferson <chris@bubblescope.net>
Benjamin Kosnik <bkoz@redhat.com>
_Bit_iterator _M_start;
_Bit_iterator _M_finish;
_Bit_type* _M_end_of_storage;
+
+ _Bvector_impl()
+ : _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage(0)
+ { }
+
_Bvector_impl(const _Bit_alloc_type& __a)
: _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0)
{ }
get_allocator() const
{ return allocator_type(_M_get_Bit_allocator()); }
- _Bvector_base(const allocator_type& __a) : _M_impl(__a) { }
+ _Bvector_base()
+ : _M_impl() { }
+
+ _Bvector_base(const allocator_type& __a)
+ : _M_impl(__a) { }
~_Bvector_base()
{ this->_M_deallocate(); }
using _Base::_M_get_Bit_allocator;
public:
+ vector()
+ : _Base() { }
+
explicit
- vector(const allocator_type& __a = allocator_type())
+ vector(const allocator_type& __a)
: _Base(__a) { }
explicit
_M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
}
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ vector(vector&& __x)
+ : _Base(__x._M_get_Bit_allocator())
+ { this->swap(__x); }
+#endif
+
template<typename _InputIterator>
vector(_InputIterator __first, _InputIterator __last,
const allocator_type& __a = allocator_type())
return *this;
}
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ vector&
+ operator=(vector&& __x)
+ {
+ this->swap(__x);
+ return *this;
+ }
+#endif
+
// assign(), a generalized assignment member function. Two
// versions: one that takes a count, and one that takes a range.
// The range version is a member template, so we dispatch on whether
}
void
- swap(vector<bool, _Alloc>& __x)
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ swap(vector&& __x)
+#else
+ swap(vector& __x)
+#endif
{
std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
_Deque_iterator(_Tp* __x, _Map_pointer __y)
: _M_cur(__x), _M_first(*__y),
- _M_last(*__y + _S_buffer_size()), _M_node(__y) {}
+ _M_last(*__y + _S_buffer_size()), _M_node(__y) { }
- _Deque_iterator() : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) {}
+ _Deque_iterator()
+ : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) { }
_Deque_iterator(const iterator& __x)
: _M_cur(__x._M_cur), _M_first(__x._M_first),
- _M_last(__x._M_last), _M_node(__x._M_node) {}
+ _M_last(__x._M_last), _M_node(__x._M_node) { }
reference
operator*() const
typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
+ _Deque_base()
+ : _M_impl()
+ { _M_initialize_map(0); }
+
_Deque_base(const allocator_type& __a, size_t __num_elements)
: _M_impl(__a)
{ _M_initialize_map(__num_elements); }
iterator _M_start;
iterator _M_finish;
+ _Deque_impl()
+ : _Tp_alloc_type(), _M_map(0), _M_map_size(0),
+ _M_start(), _M_finish()
+ { }
+
_Deque_impl(const _Tp_alloc_type& __a)
: _Tp_alloc_type(__a), _M_map(0), _M_map_size(0),
_M_start(), _M_finish()
/**
* @brief Default constructor creates no elements.
*/
+ deque()
+ : _Base() { }
+
+ /**
+ * @brief Creates a %deque with no elements.
+ * @param a An allocator object.
+ */
explicit
- deque(const allocator_type& __a = allocator_type())
- : _Base(__a, 0) {}
+ deque(const allocator_type& __a)
+ : _Base(__a, 0) { }
/**
- * @brief Create a %deque with copies of an exemplar element.
+ * @brief Creates a %deque with copies of an exemplar element.
* @param n The number of elements to initially create.
* @param value An element to copy.
+ * @param a An allocator.
*
* This constructor fills the %deque with @a n copies of @a value.
*/
this->_M_impl._M_start,
_M_get_Tp_allocator()); }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ /**
+ * @brief %Deque move constructor.
+ * @param x A %deque of identical element and allocator types.
+ *
+ * The newly-created %deque contains the exact contents of @a x.
+ * The contents of @a x are a valid, but unspecified %deque.
+ */
+ deque(deque&& __x)
+ : _Base(__x._M_get_Tp_allocator(), 0)
+ { this->swap(__x); }
+#endif
+
/**
* @brief Builds a %deque from a range.
* @param first An input iterator.
* @param last An input iterator.
+ * @param a An allocator object.
*
* Create a %deque consisting of copies of the elements from [first,
* last).
deque&
operator=(const deque& __x);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ /**
+ * @brief %Deque move assignment operator.
+ * @param x A %deque of identical element and allocator types.
+ *
+ * The contents of @a x are moved into this deque (without copying).
+ * @a x is a valid, but unspecified %deque.
+ */
+ deque&
+ operator=(deque&& __x)
+ {
+ this->swap(__x);
+ return *this;
+ }
+#endif
+
/**
* @brief Assigns a given value to a %deque.
* @param n Number of elements to be assigned.
* std::swap(d1,d2) will feed to this function.
*/
void
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ swap(deque&& __x)
+#else
swap(deque& __x)
+#endif
{
std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
{ __x.swap(__y); }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ template<typename _Tp, typename _Alloc>
+ inline void
+ swap(deque<_Tp,_Alloc>&& __x, deque<_Tp,_Alloc>& __y)
+ { __x.swap(__y); }
+
+ template<typename _Tp, typename _Alloc>
+ inline void
+ swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>&& __y)
+ { __x.swap(__y); }
+#endif
+
_GLIBCXX_END_NESTED_NAMESPACE
#endif /* _STL_DEQUE_H */
{
_List_node_base _M_node;
+ _List_impl()
+ : _Node_alloc_type(), _M_node()
+ { }
+
_List_impl(const _Node_alloc_type& __a)
: _Node_alloc_type(__a), _M_node()
{ }
get_allocator() const
{ return allocator_type(_M_get_Node_allocator()); }
+ _List_base()
+ : _M_impl()
+ { _M_init(); }
+
_List_base(const allocator_type& __a)
: _M_impl(__a)
{ _M_init(); }
/**
* @brief Default constructor creates no elements.
*/
+ list()
+ : _Base() { }
+
+ /**
+ * @brief Creates a %list with no elements.
+ * @param a An allocator object.
+ */
explicit
- list(const allocator_type& __a = allocator_type())
+ list(const allocator_type& __a)
: _Base(__a) { }
/**
- * @brief Create a %list with copies of an exemplar element.
+ * @brief Creates a %list with copies of an exemplar element.
* @param n The number of elements to initially create.
* @param value An element to copy.
+ * @param a An allocator object.
*
* This constructor fills the %list with @a n copies of @a value.
*/
: _Base(__x._M_get_Node_allocator())
{ _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ /**
+ * @brief %List move constructor.
+ * @param x A %list of identical element and allocator types.
+ *
+ * The newly-created %list contains the exact contents of @a x.
+ * The contents of @a x are a valid, but unspecified %list.
+ */
+ list(list&& __x)
+ : _Base(__x._M_get_Node_allocator())
+ { this->swap(__x); }
+#endif
+
/**
* @brief Builds a %list from a range.
* @param first An input iterator.
* @param last An input iterator.
+ * @param a An allocator object.
*
* Create a %list consisting of copies of the elements from
* [@a first,@a last). This is linear in N (where N is
list&
operator=(const list& __x);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ /**
+ * @brief %List move assignment operator.
+ * @param x A %list of identical element and allocator types.
+ *
+ * The contents of @a x are moved into this %list (without copying).
+ * @a x is a valid, but unspecified %list
+ */
+ list&
+ operator=(list&& __x)
+ {
+ this->swap(__x);
+ return *this;
+ }
+#endif
+
/**
* @brief Assigns a given value to a %list.
* @param n Number of elements to be assigned.
* function.
*/
void
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ swap(list&& __x)
+#else
swap(list& __x)
+#endif
{
_List_node_base::swap(this->_M_impl._M_node, __x._M_impl._M_node);
swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
{ __x.swap(__y); }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ template<typename _Tp, typename _Alloc>
+ inline void
+ swap(list<_Tp, _Alloc>&& __x, list<_Tp, _Alloc>& __y)
+ { __x.swap(__y); }
+
+ template<typename _Tp, typename _Alloc>
+ inline void
+ swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>&& __y)
+ { __x.swap(__y); }
+#endif
+
_GLIBCXX_END_NESTED_NAMESPACE
#endif /* _STL_LIST_H */
-
* @brief Default constructor creates no elements.
*/
map()
- : _M_t(_Compare(), allocator_type()) { }
+ : _M_t() { }
- // for some reason this was made a separate function
/**
- * @brief Default constructor creates no elements.
+ * @brief Creates a %map with no elements.
+ * @param comp A comparison object.
+ * @param a An allocator object.
*/
explicit
- map(const _Compare& __comp, const allocator_type& __a = allocator_type())
+ map(const _Compare& __comp,
+ const allocator_type& __a = allocator_type())
: _M_t(__comp, __a) { }
/**
- * @brief Map copy constructor.
+ * @brief %Map copy constructor.
* @param x A %map of identical element and allocator types.
*
- * The newly-created %map uses a copy of the allocation object used
- * by @a x.
+ * The newly-created %map uses a copy of the allocation object
+ * used by @a x.
*/
map(const map& __x)
: _M_t(__x._M_t) { }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ /**
+ * @brief %Map move constructor.
+ * @param x A %map of identical element and allocator types.
+ *
+ * The newly-created %map contains the exact contents of @a x.
+ * The contents of @a x are a valid, but unspecified %map.
+ */
+ map(map&& __x)
+ : _M_t(__x._M_t.key_comp(),
+ __x._M_t._M_get_Node_allocator())
+ { this->swap(__x); }
+#endif
+
/**
* @brief Builds a %map from a range.
* @param first An input iterator.
* This is linear in N if the range is already sorted, and NlogN
* otherwise (where N is distance(first,last)).
*/
- template <typename _InputIterator>
+ template<typename _InputIterator>
map(_InputIterator __first, _InputIterator __last)
- : _M_t(_Compare(), allocator_type())
+ : _M_t()
{ _M_t._M_insert_unique(__first, __last); }
/**
* This is linear in N if the range is already sorted, and NlogN
* otherwise (where N is distance(first,last)).
*/
- template <typename _InputIterator>
+ template<typename _InputIterator>
map(_InputIterator __first, _InputIterator __last,
- const _Compare& __comp, const allocator_type& __a = allocator_type())
+ const _Compare& __comp,
+ const allocator_type& __a = allocator_type())
: _M_t(__comp, __a)
{ _M_t._M_insert_unique(__first, __last); }
*/
/**
- * @brief Map assignment operator.
+ * @brief %Map assignment operator.
* @param x A %map of identical element and allocator types.
*
* All the elements of @a x are copied, but unlike the copy constructor,
return *this;
}
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ /**
+ * @brief %Map move assignment operator.
+ * @param x A %map of identical element and allocator types.
+ *
+ * The contents of @a x are moved into this map (without copying).
+ * @a x is a valid, but unspecified %map.
+ */
+ map&
+ operator=(map&& __x)
+ {
+ this->swap(__x);
+ return *this;
+ }
+#endif
+
/// Get a copy of the memory allocation object.
allocator_type
get_allocator() const
*
* Complexity similar to that of the range constructor.
*/
- template <typename _InputIterator>
+ template<typename _InputIterator>
void
insert(_InputIterator __first, _InputIterator __last)
{ _M_t._M_insert_unique(__first, __last); }
* that std::swap(m1,m2) will feed to this function.
*/
void
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ swap(map&& __x)
+#else
swap(map& __x)
+#endif
{ _M_t.swap(__x._M_t); }
/**
equal_range(const key_type& __x) const
{ return _M_t.equal_range(__x); }
- template <typename _K1, typename _T1, typename _C1, typename _A1>
+ template<typename _K1, typename _T1, typename _C1, typename _A1>
friend bool
- operator== (const map<_K1, _T1, _C1, _A1>&,
- const map<_K1, _T1, _C1, _A1>&);
+ operator==(const map<_K1, _T1, _C1, _A1>&,
+ const map<_K1, _T1, _C1, _A1>&);
- template <typename _K1, typename _T1, typename _C1, typename _A1>
+ template<typename _K1, typename _T1, typename _C1, typename _A1>
friend bool
- operator< (const map<_K1, _T1, _C1, _A1>&,
- const map<_K1, _T1, _C1, _A1>&);
+ operator<(const map<_K1, _T1, _C1, _A1>&,
+ const map<_K1, _T1, _C1, _A1>&);
};
/**
* maps. Maps are considered equivalent if their sizes are equal,
* and if corresponding elements compare equal.
*/
- template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+ template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
inline bool
operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
*
* See std::lexicographical_compare() for how the determination is made.
*/
- template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+ template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
inline bool
operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
{ return __x._M_t < __y._M_t; }
/// Based on operator==
- template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+ template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
inline bool
operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
{ return !(__x == __y); }
/// Based on operator<
- template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+ template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
inline bool
operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
{ return __y < __x; }
/// Based on operator<
- template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+ template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
inline bool
operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
{ return !(__y < __x); }
/// Based on operator<
- template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+ template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
inline bool
operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
{ return !(__x < __y); }
/// See std::map::swap().
- template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+ template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
inline void
swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
map<_Key, _Tp, _Compare, _Alloc>& __y)
{ __x.swap(__y); }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+ inline void
+ swap(map<_Key, _Tp, _Compare, _Alloc>&& __x,
+ map<_Key, _Tp, _Compare, _Alloc>& __y)
+ { __x.swap(__y); }
+
+ template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+ inline void
+ swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
+ map<_Key, _Tp, _Compare, _Alloc>&& __y)
+ { __x.swap(__y); }
+#endif
+
_GLIBCXX_END_NESTED_NAMESPACE
#endif /* _STL_MAP_H */
* @brief Default constructor creates no elements.
*/
multimap()
- : _M_t(_Compare(), allocator_type()) { }
+ : _M_t() { }
- // for some reason this was made a separate function
/**
- * @brief Default constructor creates no elements.
+ * @brief Creates a %multimap with no elements.
+ * @param comp A comparison object.
+ * @param a An allocator object.
*/
explicit
multimap(const _Compare& __comp,
* @brief %Multimap copy constructor.
* @param x A %multimap of identical element and allocator types.
*
- * The newly-created %multimap uses a copy of the allocation object used
- * by @a x.
+ * The newly-created %multimap uses a copy of the allocation object
+ * used by @a x.
*/
multimap(const multimap& __x)
: _M_t(__x._M_t) { }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ /**
+ * @brief %Multimap move constructor.
+ * @param x A %multimap of identical element and allocator types.
+ *
+ * The newly-created %multimap contains the exact contents of @a x.
+ * The contents of @a x are a valid, but unspecified %multimap.
+ */
+ multimap(multimap&& __x)
+ : _M_t(__x._M_t.key_comp(),
+ __x._M_t._M_get_Node_allocator())
+ { this->swap(__x); }
+#endif
+
/**
* @brief Builds a %multimap from a range.
* @param first An input iterator.
* [first,last). This is linear in N if the range is already sorted,
* and NlogN otherwise (where N is distance(first,last)).
*/
- template <typename _InputIterator>
+ template<typename _InputIterator>
multimap(_InputIterator __first, _InputIterator __last)
- : _M_t(_Compare(), allocator_type())
- { _M_t._M_insert_equal(__first, __last); }
+ : _M_t()
+ { _M_t._M_insert_unique(__first, __last); }
/**
* @brief Builds a %multimap from a range.
* [first,last). This is linear in N if the range is already sorted,
* and NlogN otherwise (where N is distance(first,last)).
*/
- template <typename _InputIterator>
+ template<typename _InputIterator>
multimap(_InputIterator __first, _InputIterator __last,
const _Compare& __comp,
const allocator_type& __a = allocator_type())
return *this;
}
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ /**
+ * @brief %Multimap move assignment operator.
+ * @param x A %multimap of identical element and allocator types.
+ *
+ * The contents of @a x are moved into this multimap (without copying).
+ * @a x is a valid, but unspecified multimap.
+ */
+ multimap&
+ operator=(multimap&& __x)
+ {
+ this->swap(__x);
+ return *this;
+ }
+#endif
+
/// Get a copy of the memory allocation object.
allocator_type
get_allocator() const
*
* Complexity similar to that of the range constructor.
*/
- template <typename _InputIterator>
+ template<typename _InputIterator>
void
insert(_InputIterator __first, _InputIterator __last)
{ _M_t._M_insert_equal(__first, __last); }
* std::swap(m1,m2) will feed to this function.
*/
void
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ swap(multimap&& __x)
+#else
swap(multimap& __x)
+#endif
{ _M_t.swap(__x._M_t); }
/**
equal_range(const key_type& __x) const
{ return _M_t.equal_range(__x); }
- template <typename _K1, typename _T1, typename _C1, typename _A1>
+ template<typename _K1, typename _T1, typename _C1, typename _A1>
friend bool
- operator== (const multimap<_K1, _T1, _C1, _A1>&,
- const multimap<_K1, _T1, _C1, _A1>&);
+ operator==(const multimap<_K1, _T1, _C1, _A1>&,
+ const multimap<_K1, _T1, _C1, _A1>&);
- template <typename _K1, typename _T1, typename _C1, typename _A1>
+ template<typename _K1, typename _T1, typename _C1, typename _A1>
friend bool
- operator< (const multimap<_K1, _T1, _C1, _A1>&,
- const multimap<_K1, _T1, _C1, _A1>&);
+ operator<(const multimap<_K1, _T1, _C1, _A1>&,
+ const multimap<_K1, _T1, _C1, _A1>&);
};
/**
* multimaps. Multimaps are considered equivalent if their sizes are equal,
* and if corresponding elements compare equal.
*/
- template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+ template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
inline bool
operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
*
* See std::lexicographical_compare() for how the determination is made.
*/
- template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+ template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
inline bool
operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
{ return __x._M_t < __y._M_t; }
/// Based on operator==
- template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+ template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
inline bool
operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
{ return !(__x == __y); }
/// Based on operator<
- template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+ template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
inline bool
operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
{ return __y < __x; }
/// Based on operator<
- template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+ template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
inline bool
operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
{ return !(__y < __x); }
/// Based on operator<
- template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+ template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
inline bool
operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
{ return !(__x < __y); }
/// See std::multimap::swap().
- template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+ template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
inline void
swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
multimap<_Key, _Tp, _Compare, _Alloc>& __y)
{ __x.swap(__y); }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+ inline void
+ swap(multimap<_Key, _Tp, _Compare, _Alloc>&& __x,
+ multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+ { __x.swap(__y); }
+
+ template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+ inline void
+ swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+ multimap<_Key, _Tp, _Compare, _Alloc>&& __y)
+ { __x.swap(__y); }
+#endif
+
_GLIBCXX_END_NESTED_NAMESPACE
#endif /* _STL_MULTIMAP_H */
* called (*_unique versus *_equal, same as the standard).
* @endif
*/
- template <class _Key, class _Compare = std::less<_Key>,
- class _Alloc = std::allocator<_Key> >
+ template <typename _Key, typename _Compare = std::less<_Key>,
+ typename _Alloc = std::allocator<_Key> >
class multiset
{
// concept requirements
typedef typename _Rep_type::difference_type difference_type;
// allocation/deallocation
-
/**
* @brief Default constructor creates no elements.
*/
multiset()
- : _M_t(_Compare(), allocator_type()) { }
+ : _M_t() { }
+ /**
+ * @brief Creates a %multiset with no elements.
+ * @param comp Comparator to use.
+ * @param a An allocator object.
+ */
explicit
multiset(const _Compare& __comp,
const allocator_type& __a = allocator_type())
* [first,last). This is linear in N if the range is already sorted,
* and NlogN otherwise (where N is distance(first,last)).
*/
- template <class _InputIterator>
+ template<typename _InputIterator>
multiset(_InputIterator __first, _InputIterator __last)
- : _M_t(_Compare(), allocator_type())
+ : _M_t()
{ _M_t._M_insert_equal(__first, __last); }
/**
* [first,last). This is linear in N if the range is already sorted,
* and NlogN otherwise (where N is distance(first,last)).
*/
- template <class _InputIterator>
+ template<typename _InputIterator>
multiset(_InputIterator __first, _InputIterator __last,
const _Compare& __comp,
const allocator_type& __a = allocator_type())
* The newly-created %multiset uses a copy of the allocation object used
* by @a x.
*/
- multiset(const multiset<_Key,_Compare,_Alloc>& __x)
+ multiset(const multiset& __x)
: _M_t(__x._M_t) { }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ /**
+ * @brief %Multiset move constructor.
+ * @param x A %multiset of identical element and allocator types.
+ *
+ * The newly-created %multiset contains the exact contents of @a x.
+ * The contents of @a x are a valid, but unspecified %multiset.
+ */
+ multiset(multiset&& __x)
+ : _M_t(__x._M_t.key_comp(),
+ __x._M_t._M_get_Node_allocator())
+ { this->swap(__x); }
+#endif
+
/**
* @brief %Multiset assignment operator.
* @param x A %multiset of identical element and allocator types.
* All the elements of @a x are copied, but unlike the copy constructor,
* the allocator object is not copied.
*/
- multiset<_Key,_Compare,_Alloc>&
- operator=(const multiset<_Key,_Compare,_Alloc>& __x)
+ multiset&
+ operator=(const multiset& __x)
{
_M_t = __x._M_t;
return *this;
}
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ /**
+ * @brief %Multiset move assignment operator.
+ * @param x A %multiset of identical element and allocator types.
+ *
+ * The contents of @a x are moved into this %multiset (without copying).
+ * @a x is a valid, but unspecified %multiset.
+ */
+ multiset&
+ operator=(multiset&& __x)
+ {
+ this->swap(__x);
+ return *this;
+ }
+#endif
+
// accessors:
/// Returns the comparison object.
* std::swap(s1,s2) will feed to this function.
*/
void
- swap(multiset<_Key, _Compare, _Alloc>& __x)
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ swap(multiset&& __x)
+#else
+ swap(multiset& __x)
+#endif
{ _M_t.swap(__x._M_t); }
// insert/erase
*
* Complexity similar to that of the range constructor.
*/
- template <class _InputIterator>
+ template<typename _InputIterator>
void
insert(_InputIterator __first, _InputIterator __last)
{ _M_t._M_insert_equal(__first, __last); }
equal_range(const key_type& __x) const
{ return _M_t.equal_range(__x); }
- template <class _K1, class _C1, class _A1>
+ template<typename _K1, typename _C1, typename _A1>
friend bool
- operator== (const multiset<_K1, _C1, _A1>&,
- const multiset<_K1, _C1, _A1>&);
+ operator==(const multiset<_K1, _C1, _A1>&,
+ const multiset<_K1, _C1, _A1>&);
- template <class _K1, class _C1, class _A1>
+ template<typename _K1, typename _C1, typename _A1>
friend bool
operator< (const multiset<_K1, _C1, _A1>&,
const multiset<_K1, _C1, _A1>&);
* Multisets are considered equivalent if their sizes are equal, and if
* corresponding elements compare equal.
*/
- template <class _Key, class _Compare, class _Alloc>
+ template<typename _Key, typename _Compare, typename _Alloc>
inline bool
operator==(const multiset<_Key, _Compare, _Alloc>& __x,
const multiset<_Key, _Compare, _Alloc>& __y)
*
* See std::lexicographical_compare() for how the determination is made.
*/
- template <class _Key, class _Compare, class _Alloc>
+ template<typename _Key, typename _Compare, typename _Alloc>
inline bool
operator<(const multiset<_Key, _Compare, _Alloc>& __x,
const multiset<_Key, _Compare, _Alloc>& __y)
{ return __x._M_t < __y._M_t; }
/// Returns !(x == y).
- template <class _Key, class _Compare, class _Alloc>
+ template<typename _Key, typename _Compare, typename _Alloc>
inline bool
operator!=(const multiset<_Key, _Compare, _Alloc>& __x,
const multiset<_Key, _Compare, _Alloc>& __y)
{ return !(__x == __y); }
/// Returns y < x.
- template <class _Key, class _Compare, class _Alloc>
+ template<typename _Key, typename _Compare, typename _Alloc>
inline bool
operator>(const multiset<_Key,_Compare,_Alloc>& __x,
const multiset<_Key,_Compare,_Alloc>& __y)
{ return __y < __x; }
/// Returns !(y < x)
- template <class _Key, class _Compare, class _Alloc>
+ template<typename _Key, typename _Compare, typename _Alloc>
inline bool
operator<=(const multiset<_Key, _Compare, _Alloc>& __x,
const multiset<_Key, _Compare, _Alloc>& __y)
{ return !(__y < __x); }
/// Returns !(x < y)
- template <class _Key, class _Compare, class _Alloc>
+ template<typename _Key, typename _Compare, typename _Alloc>
inline bool
operator>=(const multiset<_Key, _Compare, _Alloc>& __x,
const multiset<_Key, _Compare, _Alloc>& __y)
{ return !(__x < __y); }
/// See std::multiset::swap().
- template <class _Key, class _Compare, class _Alloc>
+ template<typename _Key, typename _Compare, typename _Alloc>
inline void
swap(multiset<_Key, _Compare, _Alloc>& __x,
multiset<_Key, _Compare, _Alloc>& __y)
{ __x.swap(__y); }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ template<typename _Key, typename _Compare, typename _Alloc>
+ inline void
+ swap(multiset<_Key, _Compare, _Alloc>&& __x,
+ multiset<_Key, _Compare, _Alloc>& __y)
+ { __x.swap(__y); }
+
+ template<typename _Key, typename _Compare, typename _Alloc>
+ inline void
+ swap(multiset<_Key, _Compare, _Alloc>& __x,
+ multiset<_Key, _Compare, _Alloc>&& __y)
+ { __x.swap(__y); }
+#endif
+
_GLIBCXX_END_NESTED_NAMESPACE
#endif /* _STL_MULTISET_H */
* called (*_unique versus *_equal, same as the standard).
* @endif
*/
- template<class _Key, class _Compare = std::less<_Key>,
- class _Alloc = std::allocator<_Key> >
+ template<typename _Key, typename _Compare = std::less<_Key>,
+ typename _Alloc = std::allocator<_Key> >
class set
{
// concept requirements
//@}
// allocation/deallocation
- /// Default constructor creates no elements.
+ /**
+ * @brief Default constructor creates no elements.
+ */
set()
- : _M_t(_Compare(), allocator_type()) {}
+ : _M_t() { }
/**
- * @brief Default constructor creates no elements.
- *
+ * @brief Creates a %set with no elements.
* @param comp Comparator to use.
- * @param a Allocator to use.
+ * @param a An allocator object.
*/
explicit
set(const _Compare& __comp,
const allocator_type& __a = allocator_type())
- : _M_t(__comp, __a) {}
+ : _M_t(__comp, __a) { }
/**
* @brief Builds a %set from a range.
* This is linear in N if the range is already sorted, and NlogN
* otherwise (where N is distance(first,last)).
*/
- template<class _InputIterator>
+ template<typename _InputIterator>
set(_InputIterator __first, _InputIterator __last)
- : _M_t(_Compare(), allocator_type())
+ : _M_t()
{ _M_t._M_insert_unique(__first, __last); }
/**
* This is linear in N if the range is already sorted, and NlogN
* otherwise (where N is distance(first,last)).
*/
- template<class _InputIterator>
+ template<typename _InputIterator>
set(_InputIterator __first, _InputIterator __last,
const _Compare& __comp,
const allocator_type& __a = allocator_type())
{ _M_t._M_insert_unique(__first, __last); }
/**
- * @brief Set copy constructor.
+ * @brief %Set copy constructor.
* @param x A %set of identical element and allocator types.
*
* The newly-created %set uses a copy of the allocation object used
* by @a x.
*/
- set(const set<_Key,_Compare,_Alloc>& __x)
+ set(const set& __x)
: _M_t(__x._M_t) { }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ /**
+ * @brief %Set move constructor
+ * @param x A %set of identical element and allocator types.
+ *
+ * The newly-created %set contains the exact contents of @a x.
+ * The contents of @a x are a valid, but unspecified %set.
+ */
+ set(set&& __x)
+ : _M_t(__x._M_t.key_comp(),
+ __x._M_t._M_get_Node_allocator())
+ { this->swap(__x); }
+#endif
+
/**
- * @brief Set assignment operator.
+ * @brief %Set assignment operator.
* @param x A %set of identical element and allocator types.
*
* All the elements of @a x are copied, but unlike the copy constructor,
* the allocator object is not copied.
*/
- set<_Key,_Compare,_Alloc>&
- operator=(const set<_Key, _Compare, _Alloc>& __x)
+ set&
+ operator=(const set& __x)
{
_M_t = __x._M_t;
return *this;
}
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ /**
+ * @brief %Set move assignment operator.
+ * @param x A %set of identical element and allocator types.
+ *
+ * The contents of @a x are moved into this %set (without copying).
+ * @a x is a valid, but unspecified %set.
+ */
+ set&
+ operator=(set&& __x)
+ {
+ this->swap(__x);
+ return *this;
+ }
+#endif
+
// accessors:
/// Returns the comparison object with which the %set was constructed.
* std::swap(s1,s2) will feed to this function.
*/
void
- swap(set<_Key,_Compare,_Alloc>& __x)
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ swap(set&& __x)
+#else
+ swap(set& __x)
+#endif
{ _M_t.swap(__x._M_t); }
// insert/erase
*
* Insertion requires logarithmic time.
*/
- std::pair<iterator,bool>
+ std::pair<iterator, bool>
insert(const value_type& __x)
{
std::pair<typename _Rep_type::iterator, bool> __p =
*
* Complexity similar to that of the range constructor.
*/
- template<class _InputIterator>
+ template<typename _InputIterator>
void
insert(_InputIterator __first, _InputIterator __last)
{ _M_t._M_insert_unique(__first, __last); }
{ return _M_t.equal_range(__x); }
//@}
- template<class _K1, class _C1, class _A1>
+ template<typename _K1, typename _C1, typename _A1>
friend bool
- operator== (const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
+ operator==(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
- template<class _K1, class _C1, class _A1>
+ template<typename _K1, typename _C1, typename _A1>
friend bool
- operator< (const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
+ operator<(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
};
* Sets are considered equivalent if their sizes are equal, and if
* corresponding elements compare equal.
*/
- template<class _Key, class _Compare, class _Alloc>
+ template<typename _Key, typename _Compare, typename _Alloc>
inline bool
operator==(const set<_Key, _Compare, _Alloc>& __x,
const set<_Key, _Compare, _Alloc>& __y)
*
* See std::lexicographical_compare() for how the determination is made.
*/
- template<class _Key, class _Compare, class _Alloc>
+ template<typename _Key, typename _Compare, typename _Alloc>
inline bool
operator<(const set<_Key, _Compare, _Alloc>& __x,
const set<_Key, _Compare, _Alloc>& __y)
{ return __x._M_t < __y._M_t; }
/// Returns !(x == y).
- template<class _Key, class _Compare, class _Alloc>
+ template<typename _Key, typename _Compare, typename _Alloc>
inline bool
operator!=(const set<_Key, _Compare, _Alloc>& __x,
const set<_Key, _Compare, _Alloc>& __y)
{ return !(__x == __y); }
/// Returns y < x.
- template<class _Key, class _Compare, class _Alloc>
+ template<typename _Key, typename _Compare, typename _Alloc>
inline bool
operator>(const set<_Key, _Compare, _Alloc>& __x,
const set<_Key, _Compare, _Alloc>& __y)
{ return __y < __x; }
/// Returns !(y < x)
- template<class _Key, class _Compare, class _Alloc>
+ template<typename _Key, typename _Compare, typename _Alloc>
inline bool
operator<=(const set<_Key, _Compare, _Alloc>& __x,
const set<_Key, _Compare, _Alloc>& __y)
{ return !(__y < __x); }
/// Returns !(x < y)
- template<class _Key, class _Compare, class _Alloc>
+ template<typename _Key, typename _Compare, typename _Alloc>
inline bool
operator>=(const set<_Key, _Compare, _Alloc>& __x,
const set<_Key, _Compare, _Alloc>& __y)
{ return !(__x < __y); }
/// See std::set::swap().
- template<class _Key, class _Compare, class _Alloc>
+ template<typename _Key, typename _Compare, typename _Alloc>
inline void
swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y)
{ __x.swap(__y); }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ template<typename _Key, typename _Compare, typename _Alloc>
+ inline void
+ swap(set<_Key, _Compare, _Alloc>&& __x, set<_Key, _Compare, _Alloc>& __y)
+ { __x.swap(__y); }
+
+ template<typename _Key, typename _Compare, typename _Alloc>
+ inline void
+ swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>&& __y)
+ { __x.swap(__y); }
+#endif
+
_GLIBCXX_END_NESTED_NAMESPACE
#endif /* _STL_SET_H */
_Rb_tree_node_base _M_header;
size_type _M_node_count; // Keeps track of size of tree.
- _Rb_tree_impl(const _Node_allocator& __a = _Node_allocator(),
- const _Key_compare& __comp = _Key_compare())
- : _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
+ _Rb_tree_impl()
+ : _Node_allocator(), _M_key_compare(), _M_header(),
_M_node_count(0)
+ { _M_initialize(); }
+
+ _Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)
+ : _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
+ _M_node_count(0)
+ { _M_initialize(); }
+
+ private:
+ void
+ _M_initialize()
{
this->_M_header._M_color = _S_red;
this->_M_header._M_parent = 0;
this->_M_header._M_left = &this->_M_header;
this->_M_header._M_right = &this->_M_header;
- }
+ }
};
// Specialization for _Comparison types that are not capable of
_Rb_tree_node_base _M_header;
size_type _M_node_count; // Keeps track of size of tree.
- _Rb_tree_impl(const _Node_allocator& __a = _Node_allocator(),
- const _Key_compare& __comp = _Key_compare())
+ _Rb_tree_impl()
+ : _Node_allocator(), _M_key_compare(), _M_header(),
+ _M_node_count(0)
+ { _M_initialize(); }
+
+ _Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)
: _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
_M_node_count(0)
- {
+ { _M_initialize(); }
+
+ private:
+ void
+ _M_initialize()
+ {
this->_M_header._M_color = _S_red;
this->_M_header._M_parent = 0;
this->_M_header._M_left = &this->_M_header;
this->_M_header._M_right = &this->_M_header;
- }
+ }
};
_Rb_tree_impl<_Compare> _M_impl;
public:
// allocation/deallocation
- _Rb_tree()
- { }
+ _Rb_tree() { }
- _Rb_tree(const _Compare& __comp)
- : _M_impl(allocator_type(), __comp)
- { }
+ _Rb_tree(const _Compare& __comp,
+ const allocator_type& __a = allocator_type())
+ : _M_impl(__comp, __a) { }
- _Rb_tree(const _Compare& __comp, const allocator_type& __a)
- : _M_impl(__a, __comp)
- { }
-
- _Rb_tree(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x)
- : _M_impl(__x._M_get_Node_allocator(), __x._M_impl._M_key_compare)
+ _Rb_tree(const _Rb_tree& __x)
+ : _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator())
{
if (__x._M_root() != 0)
{
~_Rb_tree()
{ _M_erase(_M_begin()); }
- _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
- operator=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x);
+ _Rb_tree&
+ operator=(const _Rb_tree& __x);
// Accessors.
_Compare
{ return get_allocator().max_size(); }
void
- swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ swap(_Rb_tree&& __t);
+#else
+ swap(_Rb_tree& __t);
+#endif
// Insert/erase.
pair<iterator, bool>
typename _Compare, typename _Alloc>
void
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&& __t)
+#else
swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t)
+#endif
{
if (_M_root() == 0)
{
_Tp* _M_start;
_Tp* _M_finish;
_Tp* _M_end_of_storage;
+
+ _Vector_impl()
+ : _Tp_alloc_type(), _M_start(0), _M_finish(0), _M_end_of_storage(0)
+ { }
+
_Vector_impl(_Tp_alloc_type const& __a)
: _Tp_alloc_type(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
{ }
get_allocator() const
{ return allocator_type(_M_get_Tp_allocator()); }
+ _Vector_base()
+ : _M_impl() { }
+
_Vector_base(const allocator_type& __a)
- : _M_impl(__a)
- { }
+ : _M_impl(__a) { }
_Vector_base(size_t __n, const allocator_type& __a)
: _M_impl(__a)
/**
* @brief Default constructor creates no elements.
*/
+ vector()
+ : _Base() { }
+
+ /**
+ * @brief Creates a %vector with no elements.
+ * @param a An allocator object.
+ */
explicit
- vector(const allocator_type& __a = allocator_type())
- : _Base(__a)
- { }
+ vector(const allocator_type& __a)
+ : _Base(__a) { }
/**
- * @brief Create a %vector with copies of an exemplar element.
+ * @brief Creates a %vector with copies of an exemplar element.
* @param n The number of elements to initially create.
* @param value An element to copy.
+ * @param a An allocator.
*
* This constructor fills the %vector with @a n copies of @a value.
*/
_M_get_Tp_allocator());
}
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ /**
+ * @brief %Vector move constructor.
+ * @param x A %vector of identical element and allocator types.
+ *
+ * The newly-created %vector contains the exact contents of @a x.
+ * The contents of @a x are a valid, but unspecified %vector.
+ */
+ vector(vector&& __x)
+ : _Base(__x._M_get_Tp_allocator())
+ { this->swap(__x); }
+#endif
+
/**
* @brief Builds a %vector from a range.
* @param first An input iterator.
* @param last An input iterator.
+ * @param a An allocator.
*
* Create a %vector consisting of copies of the elements from
* [first,last).
vector&
operator=(const vector& __x);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ /**
+ * @brief %Vector move assignment operator.
+ * @param x A %vector of identical element and allocator types.
+ *
+ * The contents of @a x are moved into this %vector (without copying).
+ * @a x is a valid, but unspecified %vector.
+ */
+ vector&
+ operator=(vector&& __x)
+ {
+ this->swap(__x);
+ return *this;
+ }
+#endif
+
/**
* @brief Assigns a given value to a %vector.
* @param n Number of elements to be assigned.
* std::swap(v1,v2) will feed to this function.
*/
void
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ swap(vector&& __x)
+#else
swap(vector& __x)
+#endif
{
std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
{ __x.swap(__y); }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ template<typename _Tp, typename _Alloc>
+ inline void
+ swap(vector<_Tp, _Alloc>&& __x, vector<_Tp, _Alloc>& __y)
+ { __x.swap(__y); }
+
+ template<typename _Tp, typename _Alloc>
+ inline void
+ swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>&& __y)
+ { __x.swap(__y); }
+#endif
+
_GLIBCXX_END_NESTED_NAMESPACE
#endif /* _STL_VECTOR_H */
// USA.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1297 }
+// { dg-error "no matching" "" { target *-*-* } 1349 }
// { dg-excess-errors "" }
#include <deque>
// USA.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1232 }
+// { dg-error "no matching" "" { target *-*-* } 1284 }
// { dg-excess-errors "" }
#include <deque>
// USA.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1232 }
+// { dg-error "no matching" "" { target *-*-* } 1284 }
// { dg-excess-errors "" }
#include <deque>
// USA.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1377 }
+// { dg-error "no matching" "" { target *-*-* } 1429 }
// { dg-excess-errors "" }
#include <deque>
// USA.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1138 }
+// { dg-error "no matching" "" { target *-*-* } 1188 }
// { dg-excess-errors "" }
#include <list>
// USA.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1107 }
+// { dg-error "no matching" "" { target *-*-* } 1157 }
// { dg-excess-errors "" }
#include <list>
// USA.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1107 }
+// { dg-error "no matching" "" { target *-*-* } 1157 }
// { dg-excess-errors "" }
#include <list>
// USA.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1107 }
+// { dg-error "no matching" "" { target *-*-* } 1157 }
// { dg-excess-errors "" }
#include <list>
// USA.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 847 }
+// { dg-error "no matching" "" { target *-*-* } 895 }
// { dg-excess-errors "" }
#include <vector>
// USA.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 787 }
+// { dg-error "no matching" "" { target *-*-* } 835 }
// { dg-excess-errors "" }
#include <vector>
// USA.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 787 }
+// { dg-error "no matching" "" { target *-*-* } 835 }
// { dg-excess-errors "" }
#include <vector>
// USA.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 888 }
+// { dg-error "no matching" "" { target *-*-* } 936 }
// { dg-excess-errors "" }
#include <vector>
projects / gcc.git / commitdiff