Subversion Repositories Kolibri OS

// Profiling iterator implementation -*- C++ -*-

// Copyright (C) 2009-2015 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.

// 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.

// 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

// .

/** @file profile/iterator_tracker.h

 *  This file is a GNU profile extension to the Standard C++ Library.

 */

#ifndef _GLIBCXX_PROFILE_ITERATOR_TRACKER

#define _GLIBCXX_PROFILE_ITERATOR_TRACKER 1

#include 

namespace std _GLIBCXX_VISIBILITY(default)

{

namespace __profile

{

  template

    class __iterator_tracker

    {

      typedef __iterator_tracker _Self;

      // The underlying iterator

      _Iterator _M_current;

      // The underlying data structure

      const _Sequence* _M_ds;

      typedef std::iterator_traits<_Iterator> _Traits;

    public:

      typedef _Iterator					_Base_iterator;

      typedef typename _Traits::iterator_category	iterator_category;

      typedef typename _Traits::value_type		value_type;

      typedef typename _Traits::difference_type		difference_type;

      typedef typename _Traits::reference		reference;

      typedef typename _Traits::pointer			pointer;

      __iterator_tracker() _GLIBCXX_NOEXCEPT

      : _M_current(), _M_ds(0) { }

      __iterator_tracker(const _Iterator& __i, const _Sequence* __seq)

      _GLIBCXX_NOEXCEPT

      : _M_current(__i), _M_ds(__seq) { }

      __iterator_tracker(const __iterator_tracker& __x) _GLIBCXX_NOEXCEPT

      : _M_current(__x._M_current), _M_ds(__x._M_ds) { }

      template

	__iterator_tracker(const __iterator_tracker<_MutableIterator,

			   typename __gnu_cxx::__enable_if

			   <(std::__are_same<_MutableIterator, typename

			     _Sequence::iterator::_Base_iterator>::__value),

			   _Sequence>::__type>& __x) _GLIBCXX_NOEXCEPT

	:  _M_current(__x.base()), _M_ds(__x._M_get_sequence()) { }

      _Iterator

      base() const _GLIBCXX_NOEXCEPT { return _M_current; }

      /**

       * @brief Conversion to underlying non-debug iterator to allow

       * better interaction with non-profile containers.

       */

      operator _Iterator() const _GLIBCXX_NOEXCEPT { return _M_current; }

      pointer

      operator->() const _GLIBCXX_NOEXCEPT { return &*_M_current; }

      __iterator_tracker&

      operator++() _GLIBCXX_NOEXCEPT

      {

	_M_ds->_M_profile_iterate();

	++_M_current;

	return *this;

      }

      __iterator_tracker

      operator++(int) _GLIBCXX_NOEXCEPT

      {

	_M_ds->_M_profile_iterate();

	__iterator_tracker __tmp(*this);

	++_M_current;

	return __tmp;

      }

      __iterator_tracker&

      operator--() _GLIBCXX_NOEXCEPT

      {

	_M_ds->_M_profile_iterate(1);

	--_M_current;

	return *this;

      }

      __iterator_tracker

      operator--(int) _GLIBCXX_NOEXCEPT

      {

	_M_ds->_M_profile_iterate(1);

	__iterator_tracker __tmp(*this);

	--_M_current;

	return __tmp;

      }

      __iterator_tracker&

      operator=(const __iterator_tracker& __x) _GLIBCXX_NOEXCEPT

      {

	_M_current = __x._M_current;

	_M_ds = __x._M_ds;

	return *this;

      }

      reference

      operator*() const _GLIBCXX_NOEXCEPT

      { return *_M_current; }

      // ------ Random access iterator requirements ------

      reference

      operator[](const difference_type& __n) const  _GLIBCXX_NOEXCEPT

      { return _M_current[__n]; }

      __iterator_tracker&

      operator+=(const difference_type& __n) _GLIBCXX_NOEXCEPT

      {

	_M_current += __n;

	return *this;

      }

      __iterator_tracker

      operator+(const difference_type& __n) const _GLIBCXX_NOEXCEPT

      {

	__iterator_tracker __tmp(*this);

	__tmp += __n;

	return __tmp;

      }

      __iterator_tracker&

      operator-=(const difference_type& __n) _GLIBCXX_NOEXCEPT

      {

	_M_current += -__n;

	return *this;

      }

      __iterator_tracker

      operator-(const difference_type& __n) const _GLIBCXX_NOEXCEPT

      {

	__iterator_tracker __tmp(*this);

	__tmp -= __n;

	return __tmp;

      }

      const _Sequence*

      _M_get_sequence() const

      { return static_cast(_M_ds); }

  };

  template

    inline bool

    operator==(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,

	       const __iterator_tracker<_IteratorR, _Sequence>& __rhs)

    _GLIBCXX_NOEXCEPT

    { return __lhs.base() == __rhs.base(); }

  template

    inline bool

    operator==(const __iterator_tracker<_Iterator, _Sequence>& __lhs,

	       const __iterator_tracker<_Iterator, _Sequence>& __rhs)

    _GLIBCXX_NOEXCEPT

    { return __lhs.base() == __rhs.base(); }

  template

    inline bool

    operator!=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,

	       const __iterator_tracker<_IteratorR, _Sequence>& __rhs)

    _GLIBCXX_NOEXCEPT

    { return __lhs.base() != __rhs.base(); }

  template

    inline bool

    operator!=(const __iterator_tracker<_Iterator, _Sequence>& __lhs,

	       const __iterator_tracker<_Iterator, _Sequence>& __rhs)

    _GLIBCXX_NOEXCEPT

    { return __lhs.base() != __rhs.base(); }

  template

    inline bool

    operator<(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,

	      const __iterator_tracker<_IteratorR, _Sequence>& __rhs)

    _GLIBCXX_NOEXCEPT

    { return __lhs.base() < __rhs.base(); }

  template

    inline bool

    operator<(const __iterator_tracker<_Iterator, _Sequence>& __lhs,

	      const __iterator_tracker<_Iterator, _Sequence>& __rhs)

    _GLIBCXX_NOEXCEPT

    { return __lhs.base() < __rhs.base(); }

  template

    inline bool

    operator<=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,

	       const __iterator_tracker<_IteratorR, _Sequence>& __rhs)

    _GLIBCXX_NOEXCEPT

    { return __lhs.base() <= __rhs.base(); }

  template

    inline bool

    operator<=(const __iterator_tracker<_Iterator, _Sequence>& __lhs,

	       const __iterator_tracker<_Iterator, _Sequence>& __rhs)

    _GLIBCXX_NOEXCEPT

    { return __lhs.base() <= __rhs.base(); }

  template

    inline bool

    operator>(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,

	      const __iterator_tracker<_IteratorR, _Sequence>& __rhs)

    _GLIBCXX_NOEXCEPT

    { return __lhs.base() > __rhs.base(); }

  template

    inline bool

    operator>(const __iterator_tracker<_Iterator, _Sequence>& __lhs,

	      const __iterator_tracker<_Iterator, _Sequence>& __rhs)

    _GLIBCXX_NOEXCEPT

    { return __lhs.base() > __rhs.base(); }

  template

    inline bool

    operator>=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,

	       const __iterator_tracker<_IteratorR, _Sequence>& __rhs)

    _GLIBCXX_NOEXCEPT

    { return __lhs.base() >= __rhs.base(); }

  template

    inline bool

    operator>=(const __iterator_tracker<_Iterator, _Sequence>& __lhs,

	       const __iterator_tracker<_Iterator, _Sequence>& __rhs)

    _GLIBCXX_NOEXCEPT

    { return __lhs.base() >= __rhs.base(); }

  // _GLIBCXX_RESOLVE_LIB_DEFECTS

  // According to the resolution of DR179 not only the various comparison

  // operators but also operator- must accept mixed iterator/const_iterator

  // parameters.

  template

    inline typename __iterator_tracker<_IteratorL, _Sequence>::difference_type

    operator-(const __iterator_tracker<_IteratorL, _Sequence>& __lhs,

	      const __iterator_tracker<_IteratorR, _Sequence>& __rhs)

    _GLIBCXX_NOEXCEPT

    { return __lhs.base() - __rhs.base(); }

  template

    inline typename __iterator_tracker<_Iterator, _Sequence>::difference_type

    operator-(const __iterator_tracker<_Iterator, _Sequence>& __lhs,

	      const __iterator_tracker<_Iterator, _Sequence>& __rhs)

    _GLIBCXX_NOEXCEPT

    { return __lhs.base() - __rhs.base(); }

  template

    inline __iterator_tracker<_Iterator, _Sequence>

    operator+(typename __iterator_tracker<_Iterator,_Sequence>::difference_type

	      __n,

	      const __iterator_tracker<_Iterator, _Sequence>& __i)

    _GLIBCXX_NOEXCEPT

    { return __i + __n; }

}  // namespace __profile

}  // namespace std

#endif