FM / detail

/usr/include/boost/intrusive/detail

Name	Size	Mode	Actions
algorithm.hpp	2880	0644	edit dl rm
algo_type.hpp	1303	0644	edit dl rm
any_node_and_algorithms.hpp	9467	0644	edit dl rm
array_initializer.hpp	2235	0644	edit dl rm
assert.hpp	1520	0644	edit dl rm
avltree_node.hpp	6714	0644	edit dl rm
bstree_algorithms_base.hpp	5523	0644	edit dl rm
common_slist_algorithms.hpp	5974	0644	edit dl rm
config_begin.hpp	2456	0644	edit dl rm
config_end.hpp	496	0644	edit dl rm
default_header_holder.hpp	2243	0644	edit dl rm
ebo_functor_holder.hpp	8005	0644	edit dl rm
empty_node_checker.hpp	1243	0644	edit dl rm
equal_to_value.hpp	1217	0644	edit dl rm
exception_disposer.hpp	2132	0644	edit dl rm
function_detector.hpp	3456	0644	edit dl rm
generic_hook.hpp	6588	0644	edit dl rm
get_value_traits.hpp	7098	0644	edit dl rm
hashtable_node.hpp	10234	0644	edit dl rm
has_member_function_callable_with.hpp	18438	0644	edit dl rm
hook_traits.hpp	8438	0644	edit dl rm
iiterator.hpp	4446	0644	edit dl rm
is_stateful_value_traits.hpp	2524	0644	edit dl rm
iterator.hpp	7612	0644	edit dl rm
key_nodeptr_comp.hpp	4882	0644	edit dl rm
list_iterator.hpp	5230	0644	edit dl rm
list_node.hpp	2152	0644	edit dl rm
math.hpp	8059	0644	edit dl rm
minimal_less_equal_header.hpp	932	0644	edit dl rm
minimal_pair_header.hpp	904	0644	edit dl rm
mpl.hpp	8592	0644	edit dl rm
node_cloner_disposer.hpp	3973	0644	edit dl rm
node_holder.hpp	883	0644	edit dl rm
node_to_value.hpp	3994	0644	edit dl rm
parent_from_member.hpp	4191	0644	edit dl rm
rbtree_node.hpp	6952	0644	edit dl rm
reverse_iterator.hpp	4644	0644	edit dl rm
simple_disposers.hpp	1177	0644	edit dl rm
size_holder.hpp	2261	0644	edit dl rm
slist_iterator.hpp	4968	0644	edit dl rm
slist_node.hpp	1907	0644	edit dl rm
std_fwd.hpp	1226	0644	edit dl rm
transform_iterator.hpp	5789	0644	edit dl rm
tree_iterator.hpp	6605	0644	edit dl rm
tree_node.hpp	2307	0644	edit dl rm
tree_value_compare.hpp	7711	0644	edit dl rm
uncast.hpp	1646	0644	edit dl rm
workaround.hpp	2061	0644	edit dl rm

Edit: /usr/include/boost/intrusive/detail/reverse_iterator.hpp (4644B)

/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga  2014-2014
//
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/intrusive for documentation.
//
/////////////////////////////////////////////////////////////////////////////

#ifndef BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP
#define BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP

#ifndef BOOST_CONFIG_HPP
#  include <boost/config.hpp>
#endif

#if defined(BOOST_HAS_PRAGMA_ONCE)
#  pragma once
#endif

#include <boost/intrusive/detail/config_begin.hpp>
#include <boost/intrusive/detail/iterator.hpp>
#include <boost/intrusive/detail/mpl.hpp>

namespace boost {
namespace intrusive {

template<class It>
class reverse_iterator
{
   public:
   typedef typename boost::intrusive::iterator_traits<It>::pointer             pointer;
   typedef typename boost::intrusive::iterator_traits<It>::reference           reference;
   typedef typename boost::intrusive::iterator_traits<It>::difference_type     difference_type;
   typedef typename boost::intrusive::iterator_traits<It>::iterator_category   iterator_category;
   typedef typename boost::intrusive::iterator_traits<It>::value_type          value_type;

typedef It iterator_type;

reverse_iterator()
      : m_current()  //Value initialization to achieve "null iterators" (N3644)
   {}

explicit reverse_iterator(It r)
      : m_current(r)
   {}

reverse_iterator(const reverse_iterator& r)
      : m_current(r.base())
   {}

template<class OtherIt>
   reverse_iterator( const reverse_iterator<OtherIt>& r
                   , typename boost::intrusive::detail::enable_if_convertible<OtherIt, It>::type* =0
                   )
      : m_current(r.base())
   {}

reverse_iterator & operator=( const reverse_iterator& r)
   {  m_current = r.base();   return *this;  }

template<class OtherIt>
   typename boost::intrusive::detail::enable_if_convertible<OtherIt, It, reverse_iterator &>::type
         operator=( const reverse_iterator<OtherIt>& r)
   {  m_current = r.base();   return *this;  }

It base() const
   {  return m_current;  }

reference operator*() const
   {
      It temp(m_current);
      --temp;
      reference r = *temp;
      return r;
   }

pointer operator->() const
   {
      It temp(m_current);
      --temp;
      return iterator_arrow_result(temp);
   }

reference operator[](difference_type off) const
   {
      return this->m_current[-off - 1];
   }

reverse_iterator& operator++()
   {
      --m_current;
      return *this;
   }

reverse_iterator operator++(int)
   {
      reverse_iterator temp((*this));
      --m_current;
      return temp;
   }

reverse_iterator& operator--()
   {
      ++m_current;
      return *this;
   }

reverse_iterator operator--(int)
   {
      reverse_iterator temp((*this));
      ++m_current;
      return temp;
   }

friend bool operator==(const reverse_iterator& l, const reverse_iterator& r)
   {  return l.m_current == r.m_current;  }

friend bool operator!=(const reverse_iterator& l, const reverse_iterator& r)
   {  return l.m_current != r.m_current;  }

friend bool operator<(const reverse_iterator& l, const reverse_iterator& r)
   {  return l.m_current > r.m_current;  }

friend bool operator<=(const reverse_iterator& l, const reverse_iterator& r)
   {  return l.m_current >= r.m_current;  }

friend bool operator>(const reverse_iterator& l, const reverse_iterator& r)
   {  return l.m_current < r.m_current;  }

friend bool operator>=(const reverse_iterator& l, const reverse_iterator& r)
   {  return l.m_current <= r.m_current;  }

reverse_iterator& operator+=(difference_type off)
   {  m_current -= off; return *this;  }

reverse_iterator& operator-=(difference_type off)
   {  m_current += off; return *this;  }

friend reverse_iterator operator+(reverse_iterator l, difference_type off)
   {  return (l += off);  }

friend reverse_iterator operator+(difference_type off, reverse_iterator r)
   {  return (r += off);   }

friend reverse_iterator operator-(reverse_iterator l, difference_type off)
   {  return (l-= off);  }

friend difference_type operator-(const reverse_iterator& l, const reverse_iterator& r)
   {  return r.m_current - l.m_current;  }

private:
   It m_current;   // the wrapped iterator
};

} //namespace intrusive {
} //namespace boost {

#include <boost/intrusive/detail/config_end.hpp>

#endif //BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP

cmd: