// Safe iterator implementation -*- C++ -*-
-// Copyright (C) 2003, 2004, 2005, 2006
-// Free Software Foundation, Inc.
+// Copyright (C) 2003-2014 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 2, or (at your option)
+// 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,
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
-// You should have received a copy of the GNU General Public License along
-// with this library; see the file COPYING. If not, write to the Free
-// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
-// USA.
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
-// As a special exception, you may use this file as part of a free software
-// library without restriction. Specifically, if other files instantiate
-// templates or use macros or inline functions from this file, or you compile
-// this file and link it with other files to produce an executable, this
-// file does not by itself cause the resulting executable to be covered by
-// the GNU General Public License. This exception does not however
-// invalidate any other reasons why the executable file might be covered by
-// the GNU General Public License.
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
/** @file debug/safe_iterator.h
* This file is a GNU debug extension to the Standard C++ Library.
#include <debug/debug.h>
#include <debug/macros.h>
#include <debug/functions.h>
-#include <debug/formatter.h>
#include <debug/safe_base.h>
#include <bits/stl_pair.h>
#include <ext/type_traits.h>
namespace __gnu_debug
{
- /** Iterators that derive from _Safe_iterator_base but that aren't
- * _Safe_iterators can be determined singular or non-singular via
- * _Safe_iterator_base.
- */
+ /** Helper struct to deal with sequence offering a before_begin
+ * iterator.
+ **/
+ template <typename _Sequence>
+ struct _BeforeBeginHelper
+ {
+ template<typename _Iterator>
+ static bool
+ _S_Is(const _Safe_iterator<_Iterator, _Sequence>&)
+ { return false; }
+
+ template<typename _Iterator>
+ static bool
+ _S_Is_Beginnest(const _Safe_iterator<_Iterator, _Sequence>& __it)
+ { return __it.base() == __it._M_get_sequence()->_M_base().begin(); }
+ };
+
+ /** Iterators that derive from _Safe_iterator_base can be determined singular
+ * or non-singular.
+ **/
inline bool
__check_singular_aux(const _Safe_iterator_base* __x)
{ return __x->_M_singular(); }
+ /** The precision to which we can calculate the distance between
+ * two iterators.
+ */
+ enum _Distance_precision
+ {
+ __dp_equality, //< Can compare iterator equality, only
+ __dp_sign, //< Can determine equality and ordering
+ __dp_exact //< Can determine distance precisely
+ };
+
+ /** Determine the distance between two iterators with some known
+ * precision.
+ */
+ template<typename _Iterator>
+ inline std::pair<typename std::iterator_traits<_Iterator>::difference_type,
+ _Distance_precision>
+ __get_distance(const _Iterator& __lhs, const _Iterator& __rhs,
+ std::random_access_iterator_tag)
+ { return std::make_pair(__rhs - __lhs, __dp_exact); }
+
+ template<typename _Iterator>
+ inline std::pair<typename std::iterator_traits<_Iterator>::difference_type,
+ _Distance_precision>
+ __get_distance(const _Iterator& __lhs, const _Iterator& __rhs,
+ std::forward_iterator_tag)
+ { return std::make_pair(__lhs == __rhs? 0 : 1, __dp_equality); }
+
+ template<typename _Iterator>
+ inline std::pair<typename std::iterator_traits<_Iterator>::difference_type,
+ _Distance_precision>
+ __get_distance(const _Iterator& __lhs, const _Iterator& __rhs)
+ {
+ typedef typename std::iterator_traits<_Iterator>::iterator_category
+ _Category;
+ return __get_distance(__lhs, __rhs, _Category());
+ }
+
/** \brief Safe iterator wrapper.
*
* The class template %_Safe_iterator is a wrapper around an
class _Safe_iterator : public _Safe_iterator_base
{
typedef _Safe_iterator _Self;
-
- /** The precision to which we can calculate the distance between
- * two iterators.
- */
- enum _Distance_precision
- {
- __dp_equality, //< Can compare iterator equality, only
- __dp_sign, //< Can determine equality and ordering
- __dp_exact //< Can determine distance precisely
- };
+ typedef typename _Sequence::const_iterator _Const_iterator;
/// The underlying iterator
_Iterator _M_current;
/// Determine if this is a constant iterator.
bool
_M_constant() const
- {
- typedef typename _Sequence::const_iterator const_iterator;
- return __is_same<const_iterator, _Safe_iterator>::value;
- }
+ { return std::__are_same<_Const_iterator, _Safe_iterator>::__value; }
typedef std::iterator_traits<_Iterator> _Traits;
public:
- typedef _Iterator _Base_iterator;
+ typedef _Iterator iterator_type;
typedef typename _Traits::iterator_category iterator_category;
typedef typename _Traits::value_type value_type;
typedef typename _Traits::difference_type difference_type;
typedef typename _Traits::pointer pointer;
/// @post the iterator is singular and unattached
- _Safe_iterator() : _M_current() { }
+ _Safe_iterator() _GLIBCXX_NOEXCEPT : _M_current() { }
/**
* @brief Safe iterator construction from an unsafe iterator and
* @post this is not singular
*/
_Safe_iterator(const _Iterator& __i, const _Sequence* __seq)
+ _GLIBCXX_NOEXCEPT
: _Safe_iterator_base(__seq, _M_constant()), _M_current(__i)
{
_GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
/**
* @brief Copy construction.
- * @pre @p x is not singular
*/
- _Safe_iterator(const _Safe_iterator& __x)
+ _Safe_iterator(const _Safe_iterator& __x) _GLIBCXX_NOEXCEPT
: _Safe_iterator_base(__x, _M_constant()), _M_current(__x._M_current)
{
- _GLIBCXX_DEBUG_VERIFY(!__x._M_singular(),
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // DR 408. Is vector<reverse_iterator<char*> > forbidden?
+ _GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
+ || __x._M_current == _Iterator(),
+ _M_message(__msg_init_copy_singular)
+ ._M_iterator(*this, "this")
+ ._M_iterator(__x, "other"));
+ }
+
+#if __cplusplus >= 201103L
+ /**
+ * @brief Move construction.
+ * @post __x is singular and unattached
+ */
+ _Safe_iterator(_Safe_iterator&& __x) noexcept : _M_current()
+ {
+ _GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
+ || __x._M_current == _Iterator(),
_M_message(__msg_init_copy_singular)
._M_iterator(*this, "this")
._M_iterator(__x, "other"));
+ std::swap(_M_current, __x._M_current);
+ this->_M_attach(__x._M_sequence);
+ __x._M_detach();
}
+#endif
/**
* @brief Converting constructor from a mutable iterator to a
* constant iterator.
- *
- * @pre @p x is not singular
*/
template<typename _MutableIterator>
_Safe_iterator(
const _Safe_iterator<_MutableIterator,
typename __gnu_cxx::__enable_if<(std::__are_same<_MutableIterator,
- typename _Sequence::iterator::_Base_iterator>::__value),
- _Sequence>::__type>& __x)
+ typename _Sequence::iterator::iterator_type>::__value),
+ _Sequence>::__type>& __x) _GLIBCXX_NOEXCEPT
: _Safe_iterator_base(__x, _M_constant()), _M_current(__x.base())
{
- _GLIBCXX_DEBUG_VERIFY(!__x._M_singular(),
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // DR 408. Is vector<reverse_iterator<char*> > forbidden?
+ _GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
+ || __x.base() == _Iterator(),
_M_message(__msg_init_const_singular)
._M_iterator(*this, "this")
._M_iterator(__x, "other"));
/**
* @brief Copy assignment.
- * @pre @p x is not singular
*/
_Safe_iterator&
- operator=(const _Safe_iterator& __x)
+ operator=(const _Safe_iterator& __x) _GLIBCXX_NOEXCEPT
{
- _GLIBCXX_DEBUG_VERIFY(!__x._M_singular(),
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // DR 408. Is vector<reverse_iterator<char*> > forbidden?
+ _GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
+ || __x._M_current == _Iterator(),
_M_message(__msg_copy_singular)
._M_iterator(*this, "this")
._M_iterator(__x, "other"));
_M_current = __x._M_current;
- this->_M_attach(static_cast<_Sequence*>(__x._M_sequence));
+ this->_M_attach(__x._M_sequence);
return *this;
}
+#if __cplusplus >= 201103L
+ /**
+ * @brief Move assignment.
+ * @post __x is singular and unattached
+ */
+ _Safe_iterator&
+ operator=(_Safe_iterator&& __x) noexcept
+ {
+ _GLIBCXX_DEBUG_VERIFY(this != &__x,
+ _M_message(__msg_self_move_assign)
+ ._M_iterator(*this, "this"));
+ _GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
+ || __x._M_current == _Iterator(),
+ _M_message(__msg_copy_singular)
+ ._M_iterator(*this, "this")
+ ._M_iterator(__x, "other"));
+ _M_current = __x._M_current;
+ _M_attach(__x._M_sequence);
+ __x._M_detach();
+ __x._M_current = _Iterator();
+ return *this;
+ }
+#endif
+
/**
* @brief Iterator dereference.
* @pre iterator is dereferenceable
*/
reference
- operator*() const
+ operator*() const _GLIBCXX_NOEXCEPT
{
-
_GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(),
_M_message(__msg_bad_deref)
._M_iterator(*this, "this"));
* @brief Iterator dereference.
* @pre iterator is dereferenceable
* @todo Make this correct w.r.t. iterators that return proxies
- * @todo Use addressof() instead of & operator
*/
pointer
- operator->() const
+ operator->() const _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(),
_M_message(__msg_bad_deref)
._M_iterator(*this, "this"));
- return &*_M_current;
+ return std::__addressof(*_M_current);
}
// ------ Input iterator requirements ------
* @pre iterator is incrementable
*/
_Safe_iterator&
- operator++()
+ operator++() _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(),
_M_message(__msg_bad_inc)
* @pre iterator is incrementable
*/
_Safe_iterator
- operator++(int)
+ operator++(int) _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(),
_M_message(__msg_bad_inc)
* @pre iterator is decrementable
*/
_Safe_iterator&
- operator--()
+ operator--() _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(),
_M_message(__msg_bad_dec)
* @pre iterator is decrementable
*/
_Safe_iterator
- operator--(int)
+ operator--(int) _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(),
_M_message(__msg_bad_dec)
// ------ Random access iterator requirements ------
reference
- operator[](const difference_type& __n) const
+ operator[](const difference_type& __n) const _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n)
&& this->_M_can_advance(__n+1),
}
_Safe_iterator&
- operator+=(const difference_type& __n)
+ operator+=(const difference_type& __n) _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n),
_M_message(__msg_advance_oob)
}
_Safe_iterator
- operator+(const difference_type& __n) const
+ operator+(const difference_type& __n) const _GLIBCXX_NOEXCEPT
{
_Safe_iterator __tmp(*this);
__tmp += __n;
}
_Safe_iterator&
- operator-=(const difference_type& __n)
+ operator-=(const difference_type& __n) _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(-__n),
_M_message(__msg_retreat_oob)
}
_Safe_iterator
- operator-(const difference_type& __n) const
+ operator-(const difference_type& __n) const _GLIBCXX_NOEXCEPT
{
_Safe_iterator __tmp(*this);
__tmp -= __n;
* @brief Return the underlying iterator
*/
_Iterator
- base() const { return _M_current; }
+ base() const _GLIBCXX_NOEXCEPT { return _M_current; }
/**
* @brief Conversion to underlying non-debug iterator to allow
* better interaction with non-debug containers.
*/
- operator _Iterator() const { return _M_current; }
+ operator _Iterator() const _GLIBCXX_NOEXCEPT { return _M_current; }
/** Attach iterator to the given sequence. */
void
- _M_attach(const _Sequence* __seq)
+ _M_attach(_Safe_sequence_base* __seq)
{
- _Safe_iterator_base::_M_attach(const_cast<_Sequence*>(__seq),
- _M_constant());
+ _Safe_iterator_base::_M_attach(__seq, _M_constant());
}
/** Likewise, but not thread-safe. */
void
- _M_attach_single(const _Sequence* __seq)
+ _M_attach_single(_Safe_sequence_base* __seq)
{
- _Safe_iterator_base::_M_attach_single(const_cast<_Sequence*>(__seq),
- _M_constant());
+ _Safe_iterator_base::_M_attach_single(__seq, _M_constant());
}
- /** Invalidate the iterator, making it singular. */
- void
- _M_invalidate();
-
- /** Likewise, but not thread-safe. */
- void
- _M_invalidate_single();
-
/// Is the iterator dereferenceable?
bool
_M_dereferenceable() const
- { return !this->_M_singular() && !_M_is_end(); }
+ { return !this->_M_singular() && !_M_is_end() && !_M_is_before_begin(); }
+
+ /// Is the iterator before a dereferenceable one?
+ bool
+ _M_before_dereferenceable() const
+ {
+ if (this->_M_incrementable())
+ {
+ _Iterator __base = base();
+ return ++__base != _M_get_sequence()->_M_base().end();
+ }
+ return false;
+ }
/// Is the iterator incrementable?
bool
- _M_incrementable() const { return this->_M_dereferenceable(); }
+ _M_incrementable() const
+ { return !this->_M_singular() && !_M_is_end(); }
// Is the iterator decrementable?
bool
_M_can_advance(const difference_type& __n) const;
// Is the iterator range [*this, __rhs) valid?
- template<typename _Other>
- bool
- _M_valid_range(const _Safe_iterator<_Other, _Sequence>& __rhs) const;
+ bool
+ _M_valid_range(const _Safe_iterator& __rhs) const;
// The sequence this iterator references.
- const _Sequence*
+ typename
+ __gnu_cxx::__conditional_type<std::__are_same<_Const_iterator,
+ _Safe_iterator>::__value,
+ const _Sequence*,
+ _Sequence*>::__type
_M_get_sequence() const
- { return static_cast<const _Sequence*>(_M_sequence); }
-
- /** Determine the distance between two iterators with some known
- * precision.
- */
- template<typename _Iterator1, typename _Iterator2>
- static std::pair<difference_type, _Distance_precision>
- _M_get_distance(const _Iterator1& __lhs, const _Iterator2& __rhs)
- {
- typedef typename std::iterator_traits<_Iterator1>::iterator_category
- _Category;
- return _M_get_distance(__lhs, __rhs, _Category());
- }
-
- template<typename _Iterator1, typename _Iterator2>
- static std::pair<difference_type, _Distance_precision>
- _M_get_distance(const _Iterator1& __lhs, const _Iterator2& __rhs,
- std::random_access_iterator_tag)
- {
- return std::make_pair(__rhs.base() - __lhs.base(), __dp_exact);
- }
-
- template<typename _Iterator1, typename _Iterator2>
- static std::pair<difference_type, _Distance_precision>
- _M_get_distance(const _Iterator1& __lhs, const _Iterator2& __rhs,
- std::forward_iterator_tag)
- {
- return std::make_pair(__lhs.base() == __rhs.base()? 0 : 1,
- __dp_equality);
- }
+ { return static_cast<_Sequence*>(_M_sequence); }
/// Is this iterator equal to the sequence's begin() iterator?
- bool _M_is_begin() const
- { return *this == static_cast<const _Sequence*>(_M_sequence)->begin(); }
+ bool
+ _M_is_begin() const
+ { return base() == _M_get_sequence()->_M_base().begin(); }
/// Is this iterator equal to the sequence's end() iterator?
- bool _M_is_end() const
- { return *this == static_cast<const _Sequence*>(_M_sequence)->end(); }
+ bool
+ _M_is_end() const
+ { return base() == _M_get_sequence()->_M_base().end(); }
+
+ /// Is this iterator equal to the sequence's before_begin() iterator if
+ /// any?
+ bool
+ _M_is_before_begin() const
+ { return _BeforeBeginHelper<_Sequence>::_S_Is(*this); }
+
+ /// Is this iterator equal to the sequence's before_begin() iterator if
+ /// any or begin() otherwise?
+ bool
+ _M_is_beginnest() const
+ { return _BeforeBeginHelper<_Sequence>::_S_Is_Beginnest(*this); }
};
template<typename _IteratorL, typename _IteratorR, typename _Sequence>
inline bool
operator==(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+ _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_compare_bad)
inline bool
operator==(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+ _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_compare_bad)
inline bool
operator!=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+ _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_compare_bad)
inline bool
operator!=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+ _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_compare_bad)
inline bool
operator<(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+ _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_order_bad)
inline bool
operator<(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+ _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_order_bad)
inline bool
operator<=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+ _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_order_bad)
inline bool
operator<=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+ _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_order_bad)
inline bool
operator>(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+ _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_order_bad)
inline bool
operator>(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+ _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_order_bad)
inline bool
operator>=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+ _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_order_bad)
inline bool
operator>=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+ _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_order_bad)
inline typename _Safe_iterator<_IteratorL, _Sequence>::difference_type
operator-(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+ _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_distance_bad)
inline typename _Safe_iterator<_Iterator, _Sequence>::difference_type
operator-(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
const _Safe_iterator<_Iterator, _Sequence>& __rhs)
+ _GLIBCXX_NOEXCEPT
{
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_distance_bad)
template<typename _Iterator, typename _Sequence>
inline _Safe_iterator<_Iterator, _Sequence>
operator+(typename _Safe_iterator<_Iterator,_Sequence>::difference_type __n,
- const _Safe_iterator<_Iterator, _Sequence>& __i)
+ const _Safe_iterator<_Iterator, _Sequence>& __i) _GLIBCXX_NOEXCEPT
{ return __i + __n; }
} // namespace __gnu_debug
-#ifndef _GLIBCXX_EXPORT_TEMPLATE
-# include <debug/safe_iterator.tcc>
-#endif
+#include <debug/safe_iterator.tcc>
#endif