+2013-09-20 Marc Glisse <marc.glisse@inria.fr>
+
+ PR libstdc++/58338
+ * include/bits/allocator.h (__alloc_swap::_S_do_it,
+ __shrink_to_fit_aux::_S_do_it): Mark as noexcept.
+ * include/bits/basic_string.h (basic_string::_Rep) [_S_empty_rep,
+ _M_is_leaked, _M_is_shared, _M_set_leaked, _M_set_sharable,
+ _M_set_length_and_sharable, _M_dispose]: Likewise.
+ (basic_string::_Alloc_hider::_Alloc_hider): Likewise.
+ (basic_string) [_M_data, _M_rep, _M_ibegin, _M_iend, _M_limit,
+ _M_disjunct, _M_copy, _M_move, _M_assign, _S_copy_chars, _S_compare,
+ _S_empty_rep, shrink_to_fit, operator[] const, front const, back const]:
+ Likewise.
+ [clear]: Link to PR 56166.
+ [swap]: Link to PR 58265.
+ * include/bits/stl_deque.h (_Deque_iterator) [_S_buffer_size,
+ _Deque_iterator, _M_const_cast, operator*, operator->, operator++,
+ operator--, operator+=, operator+, operator-=, operator-, operator[],
+ _M_set_node]: Mark as noexcept.
+ (operator==(const _Deque_iterator&, const _Deque_iterator&),
+ operator!=(const _Deque_iterator&, const _Deque_iterator&),
+ operator<(const _Deque_iterator&, const _Deque_iterator&),
+ operator>(const _Deque_iterator&, const _Deque_iterator&),
+ operator<=(const _Deque_iterator&, const _Deque_iterator&),
+ operator>=(const _Deque_iterator&, const _Deque_iterator&),
+ operator-(const _Deque_iterator&, const _Deque_iterator&),
+ operator+(ptrdiff_t, const _Deque_iterator&)): Likewise.
+ (_Deque_base) [_Deque_base(const allocator_type&)]: Add missing call to
+ _M_initialize_map.
+ [~_Deque_base, _M_deallocate_node, _M_deallocate_map, _M_destroy_nodes]:
+ Mark as noexcept.
+ (_Deque_base::_Deque_impl) [_Deque_impl(const _Tp_alloc_type&),
+ _Deque_impl(_Tp_alloc_type&&)]: Likewise.
+ (deque) [_S_buffer_size, operator=(deque&&), shrink_to_fit, operator[],
+ front, back, pop_front, pop_back, swap]: Likewise.
+ [deque(), deque(const allocator_type&)]: Merge.
+ * include/debug/deque (deque) [operator=(deque&&), shrink_to_fit,
+ operator[], front, back, pop_front, pop_back, swap]: Mark as noexcept.
+ * include/profile/deque (deque) [operator=(deque&&), operator[], front,
+ back, pop_front, pop_back, swap]: Likewise.
+ * testsuite/23_containers/deque/requirements/dr438/assign_neg.cc:
+ Adjust line number.
+ * 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/deque/requirements/dr438/insert_neg.cc:
+ Likewise.
+
2013-09-20 Alan Modra <amodra@gmail.com>
* configure: Regenerate.
static size_type _S_empty_rep_storage[];
static _Rep&
- _S_empty_rep()
+ _S_empty_rep() _GLIBCXX_NOEXCEPT
{
// NB: Mild hack to avoid strict-aliasing warnings. Note that
// _S_empty_rep_storage is never modified and the punning should
}
bool
- _M_is_leaked() const
+ _M_is_leaked() const _GLIBCXX_NOEXCEPT
{ return this->_M_refcount < 0; }
bool
- _M_is_shared() const
+ _M_is_shared() const _GLIBCXX_NOEXCEPT
{ return this->_M_refcount > 0; }
void
- _M_set_leaked()
+ _M_set_leaked() _GLIBCXX_NOEXCEPT
{ this->_M_refcount = -1; }
void
- _M_set_sharable()
+ _M_set_sharable() _GLIBCXX_NOEXCEPT
{ this->_M_refcount = 0; }
void
- _M_set_length_and_sharable(size_type __n)
+ _M_set_length_and_sharable(size_type __n) _GLIBCXX_NOEXCEPT
{
#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
if (__builtin_expect(this != &_S_empty_rep(), false))
_S_create(size_type, size_type, const _Alloc&);
void
- _M_dispose(const _Alloc& __a)
+ _M_dispose(const _Alloc& __a) _GLIBCXX_NOEXCEPT
{
#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
if (__builtin_expect(this != &_S_empty_rep(), false))
// Use empty-base optimization: http://www.cantrip.org/emptyopt.html
struct _Alloc_hider : _Alloc
{
- _Alloc_hider(_CharT* __dat, const _Alloc& __a)
+ _Alloc_hider(_CharT* __dat, const _Alloc& __a) _GLIBCXX_NOEXCEPT
: _Alloc(__a), _M_p(__dat) { }
_CharT* _M_p; // The actual data.
mutable _Alloc_hider _M_dataplus;
_CharT*
- _M_data() const
+ _M_data() const _GLIBCXX_NOEXCEPT
{ return _M_dataplus._M_p; }
_CharT*
- _M_data(_CharT* __p)
+ _M_data(_CharT* __p) _GLIBCXX_NOEXCEPT
{ return (_M_dataplus._M_p = __p); }
_Rep*
- _M_rep() const
+ _M_rep() const _GLIBCXX_NOEXCEPT
{ return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
// For the internal use we have functions similar to `begin'/`end'
// but they do not call _M_leak.
iterator
- _M_ibegin() const
+ _M_ibegin() const _GLIBCXX_NOEXCEPT
{ return iterator(_M_data()); }
iterator
- _M_iend() const
+ _M_iend() const _GLIBCXX_NOEXCEPT
{ return iterator(_M_data() + this->size()); }
void
// NB: _M_limit doesn't check for a bad __pos value.
size_type
- _M_limit(size_type __pos, size_type __off) const
+ _M_limit(size_type __pos, size_type __off) const _GLIBCXX_NOEXCEPT
{
const bool __testoff = __off < this->size() - __pos;
return __testoff ? __off : this->size() - __pos;
// True if _Rep and source do not overlap.
bool
- _M_disjunct(const _CharT* __s) const
+ _M_disjunct(const _CharT* __s) const _GLIBCXX_NOEXCEPT
{
return (less<const _CharT*>()(__s, _M_data())
|| less<const _CharT*>()(_M_data() + this->size(), __s));
// When __n = 1 way faster than the general multichar
// traits_type::copy/move/assign.
static void
- _M_copy(_CharT* __d, const _CharT* __s, size_type __n)
+ _M_copy(_CharT* __d, const _CharT* __s, size_type __n) _GLIBCXX_NOEXCEPT
{
if (__n == 1)
traits_type::assign(*__d, *__s);
}
static void
- _M_move(_CharT* __d, const _CharT* __s, size_type __n)
+ _M_move(_CharT* __d, const _CharT* __s, size_type __n) _GLIBCXX_NOEXCEPT
{
if (__n == 1)
traits_type::assign(*__d, *__s);
}
static void
- _M_assign(_CharT* __d, size_type __n, _CharT __c)
+ _M_assign(_CharT* __d, size_type __n, _CharT __c) _GLIBCXX_NOEXCEPT
{
if (__n == 1)
traits_type::assign(*__d, __c);
template<class _Iterator>
static void
_S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
+ _GLIBCXX_NOEXCEPT
{
for (; __k1 != __k2; ++__k1, ++__p)
traits_type::assign(*__p, *__k1); // These types are off.
}
static void
- _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
+ _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) _GLIBCXX_NOEXCEPT
{ _S_copy_chars(__p, __k1.base(), __k2.base()); }
static void
_S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
+ _GLIBCXX_NOEXCEPT
{ _S_copy_chars(__p, __k1.base(), __k2.base()); }
static void
- _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
+ _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) _GLIBCXX_NOEXCEPT
{ _M_copy(__p, __k1, __k2 - __k1); }
static void
_S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
+ _GLIBCXX_NOEXCEPT
{ _M_copy(__p, __k1, __k2 - __k1); }
static int
- _S_compare(size_type __n1, size_type __n2)
+ _S_compare(size_type __n1, size_type __n2) _GLIBCXX_NOEXCEPT
{
const difference_type __d = difference_type(__n1 - __n2);
_M_leak_hard();
static _Rep&
- _S_empty_rep()
+ _S_empty_rep() _GLIBCXX_NOEXCEPT
{ return _Rep::_S_empty_rep(); }
public:
#if __cplusplus >= 201103L
/// A non-binding request to reduce capacity() to size().
void
- shrink_to_fit()
+ shrink_to_fit() _GLIBCXX_NOEXCEPT
{
if (capacity() > size())
{
/**
* Erases the string, making it empty.
*/
+ // PR 56166: this should not throw.
void
clear() _GLIBCXX_NOEXCEPT
{ _M_mutate(0, this->size(), 0); }
* see at().)
*/
const_reference
- operator[] (size_type __pos) const
+ operator[] (size_type __pos) const _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_ASSERT(__pos <= size());
return _M_data()[__pos];
* element of the %string.
*/
const_reference
- front() const
+ front() const _GLIBCXX_NOEXCEPT
{ return operator[](0); }
/**
* last element of the %string.
*/
const_reference
- back() const
+ back() const _GLIBCXX_NOEXCEPT
{ return operator[](this->size() - 1); }
#endif
* Exchanges the contents of this string with that of @a __s in constant
* time.
*/
+ // PR 58265, this should be noexcept.
void
swap(basic_string& __s);
typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
- static size_t _S_buffer_size()
+ static size_t _S_buffer_size() _GLIBCXX_NOEXCEPT
{ return __deque_buf_size(sizeof(_Tp)); }
typedef std::random_access_iterator_tag iterator_category;
_Tp* _M_last;
_Map_pointer _M_node;
- _Deque_iterator(_Tp* __x, _Map_pointer __y)
+ _Deque_iterator(_Tp* __x, _Map_pointer __y) _GLIBCXX_NOEXCEPT
: _M_cur(__x), _M_first(*__y),
_M_last(*__y + _S_buffer_size()), _M_node(__y) { }
- _Deque_iterator()
+ _Deque_iterator() _GLIBCXX_NOEXCEPT
: _M_cur(0), _M_first(0), _M_last(0), _M_node(0) { }
- _Deque_iterator(const iterator& __x)
+ _Deque_iterator(const iterator& __x) _GLIBCXX_NOEXCEPT
: _M_cur(__x._M_cur), _M_first(__x._M_first),
_M_last(__x._M_last), _M_node(__x._M_node) { }
iterator
- _M_const_cast() const
+ _M_const_cast() const _GLIBCXX_NOEXCEPT
{ return iterator(_M_cur, _M_node); }
reference
- operator*() const
+ operator*() const _GLIBCXX_NOEXCEPT
{ return *_M_cur; }
pointer
- operator->() const
+ operator->() const _GLIBCXX_NOEXCEPT
{ return _M_cur; }
_Self&
- operator++()
+ operator++() _GLIBCXX_NOEXCEPT
{
++_M_cur;
if (_M_cur == _M_last)
}
_Self
- operator++(int)
+ operator++(int) _GLIBCXX_NOEXCEPT
{
_Self __tmp = *this;
++*this;
}
_Self&
- operator--()
+ operator--() _GLIBCXX_NOEXCEPT
{
if (_M_cur == _M_first)
{
}
_Self
- operator--(int)
+ operator--(int) _GLIBCXX_NOEXCEPT
{
_Self __tmp = *this;
--*this;
}
_Self&
- operator+=(difference_type __n)
+ operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
{
const difference_type __offset = __n + (_M_cur - _M_first);
if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
}
_Self
- operator+(difference_type __n) const
+ operator+(difference_type __n) const _GLIBCXX_NOEXCEPT
{
_Self __tmp = *this;
return __tmp += __n;
}
_Self&
- operator-=(difference_type __n)
+ operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
{ return *this += -__n; }
_Self
- operator-(difference_type __n) const
+ operator-(difference_type __n) const _GLIBCXX_NOEXCEPT
{
_Self __tmp = *this;
return __tmp -= __n;
}
reference
- operator[](difference_type __n) const
+ operator[](difference_type __n) const _GLIBCXX_NOEXCEPT
{ return *(*this + __n); }
/**
* immediately afterwards, based on _M_first and _M_last.
*/
void
- _M_set_node(_Map_pointer __new_node)
+ _M_set_node(_Map_pointer __new_node) _GLIBCXX_NOEXCEPT
{
_M_node = __new_node;
_M_first = *__new_node;
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
- const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+ const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT
{ return __x._M_cur == __y._M_cur; }
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
- const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+ const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT
{ return __x._M_cur == __y._M_cur; }
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
- const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+ const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT
{ return !(__x == __y); }
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
- const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+ const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT
{ return !(__x == __y); }
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator<(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
- const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+ const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT
{ return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
: (__x._M_node < __y._M_node); }
typename _RefR, typename _PtrR>
inline bool
operator<(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
- const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+ const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT
{ return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
: (__x._M_node < __y._M_node); }
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator>(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
- const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+ const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT
{ return __y < __x; }
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator>(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
- const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+ const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT
{ return __y < __x; }
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator<=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
- const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+ const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT
{ return !(__y < __x); }
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator<=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
- const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+ const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT
{ return !(__y < __x); }
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator>=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
- const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+ const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT
{ return !(__x < __y); }
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator>=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
- const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+ const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT
{ return !(__x < __y); }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
template<typename _Tp, typename _Ref, typename _Ptr>
inline typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
operator-(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
- const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+ const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT
{
return typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
(_Deque_iterator<_Tp, _Ref, _Ptr>::_S_buffer_size())
typename _RefR, typename _PtrR>
inline typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
operator-(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
- const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+ const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT
{
return typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
(_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size())
template<typename _Tp, typename _Ref, typename _Ptr>
inline _Deque_iterator<_Tp, _Ref, _Ptr>
operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x)
+ _GLIBCXX_NOEXCEPT
{ return __x + __n; }
template<typename _Tp>
_Deque_base(const allocator_type& __a)
: _M_impl(__a)
- { }
+ { _M_initialize_map(0); }
#if __cplusplus >= 201103L
_Deque_base(_Deque_base&& __x)
}
#endif
- ~_Deque_base();
+ ~_Deque_base() _GLIBCXX_NOEXCEPT;
protected:
//This struct encapsulates the implementation of the std::deque
_M_start(), _M_finish()
{ }
- _Deque_impl(const _Tp_alloc_type& __a)
+ _Deque_impl(const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT
: _Tp_alloc_type(__a), _M_map(0), _M_map_size(0),
_M_start(), _M_finish()
{ }
#if __cplusplus >= 201103L
- _Deque_impl(_Tp_alloc_type&& __a)
+ _Deque_impl(_Tp_alloc_type&& __a) _GLIBCXX_NOEXCEPT
: _Tp_alloc_type(std::move(__a)), _M_map(0), _M_map_size(0),
_M_start(), _M_finish()
{ }
}
void
- _M_deallocate_node(_Tp* __p)
+ _M_deallocate_node(_Tp* __p) _GLIBCXX_NOEXCEPT
{
_M_impl._Tp_alloc_type::deallocate(__p, __deque_buf_size(sizeof(_Tp)));
}
{ return _M_get_map_allocator().allocate(__n); }
void
- _M_deallocate_map(_Tp** __p, size_t __n)
+ _M_deallocate_map(_Tp** __p, size_t __n) _GLIBCXX_NOEXCEPT
{ _M_get_map_allocator().deallocate(__p, __n); }
protected:
void _M_initialize_map(size_t);
void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish);
- void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish);
+ void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish) _GLIBCXX_NOEXCEPT;
enum { _S_initial_map_size = 8 };
_Deque_impl _M_impl;
template<typename _Tp, typename _Alloc>
_Deque_base<_Tp, _Alloc>::
- ~_Deque_base()
+ ~_Deque_base() _GLIBCXX_NOEXCEPT
{
if (this->_M_impl._M_map)
{
template<typename _Tp, typename _Alloc>
void
_Deque_base<_Tp, _Alloc>::
- _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish)
+ _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish) _GLIBCXX_NOEXCEPT
{
for (_Tp** __n = __nstart; __n < __nfinish; ++__n)
_M_deallocate_node(*__n);
protected:
typedef pointer* _Map_pointer;
- static size_t _S_buffer_size()
+ static size_t _S_buffer_size() _GLIBCXX_NOEXCEPT
{ return __deque_buf_size(sizeof(_Tp)); }
// Functions controlling memory layout, and nothing else.
public:
// [23.2.1.1] construct/copy/destroy
// (assign() and get_allocator() are also listed in this section)
- /**
- * @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)
- : _Base(__a, 0) { }
+ deque(const allocator_type& __a = allocator_type())
+ : _Base(__a) { }
#if __cplusplus >= 201103L
/**
* @a __x is a valid, but unspecified %deque.
*/
deque&
- operator=(deque&& __x)
+ operator=(deque&& __x) noexcept
{
// NB: DR 1204.
// NB: DR 675.
#if __cplusplus >= 201103L
/** A non-binding request to reduce memory use. */
void
- shrink_to_fit()
+ shrink_to_fit() noexcept
{ _M_shrink_to_fit(); }
#endif
* see at().)
*/
reference
- operator[](size_type __n)
+ operator[](size_type __n) _GLIBCXX_NOEXCEPT
{ return this->_M_impl._M_start[difference_type(__n)]; }
/**
* see at().)
*/
const_reference
- operator[](size_type __n) const
+ operator[](size_type __n) const _GLIBCXX_NOEXCEPT
{ return this->_M_impl._M_start[difference_type(__n)]; }
protected:
* element of the %deque.
*/
reference
- front()
+ front() _GLIBCXX_NOEXCEPT
{ return *begin(); }
/**
* element of the %deque.
*/
const_reference
- front() const
+ front() const _GLIBCXX_NOEXCEPT
{ return *begin(); }
/**
* %deque.
*/
reference
- back()
+ back() _GLIBCXX_NOEXCEPT
{
iterator __tmp = end();
--__tmp;
* element of the %deque.
*/
const_reference
- back() const
+ back() const _GLIBCXX_NOEXCEPT
{
const_iterator __tmp = end();
--__tmp;
* needed, it should be retrieved before pop_front() is called.
*/
void
- pop_front()
+ pop_front() _GLIBCXX_NOEXCEPT
{
if (this->_M_impl._M_start._M_cur
!= this->_M_impl._M_start._M_last - 1)
* needed, it should be retrieved before pop_back() is called.
*/
void
- pop_back()
+ pop_back() _GLIBCXX_NOEXCEPT
{
if (this->_M_impl._M_finish._M_cur
!= this->_M_impl._M_finish._M_first)
* std::swap(d1,d2) will feed to this function.
*/
void
- swap(deque& __x)
+ swap(deque& __x) _GLIBCXX_NOEXCEPT
{
std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
projects / thirdparty / gcc.git / commitdiff
