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/iterator.hpp (7612B)

/////////////////////////////////////////////////////////////////////////////
//
// (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_ITERATOR_HPP
#define BOOST_INTRUSIVE_DETAIL_ITERATOR_HPP

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

#if defined(BOOST_HAS_PRAGMA_ONCE)
#  pragma once
#endif

#include <cstddef>
#include <boost/intrusive/detail/std_fwd.hpp>
#include <boost/intrusive/detail/workaround.hpp>
#include <boost/move/detail/iterator_traits.hpp>
#include <boost/move/detail/meta_utils_core.hpp>

namespace boost{
namespace iterators{

struct incrementable_traversal_tag;
struct single_pass_traversal_tag;
struct forward_traversal_tag;
struct bidirectional_traversal_tag;
struct random_access_traversal_tag;

namespace detail{

template <class Category, class Traversal>
struct iterator_category_with_traversal;

} //namespace boost{
} //namespace iterators{
} //namespace detail{

namespace boost {
namespace intrusive {

using boost::movelib::iterator_traits;

////////////////////
// iterator
////////////////////
template<class Category, class T, class Difference, class Pointer, class Reference>
struct iterator
{
 typedef Category iterator_category;
 typedef T value_type;
 typedef Difference difference_type;
 typedef Pointer pointer;
 typedef Reference reference;
};

////////////////////////////////////////
// iterator_[dis|en]able_if_boost_iterator
////////////////////////////////////////
template<class I>
struct is_boost_iterator
{
 static const bool value = false;
};

template<class Category, class Traversal>
struct is_boost_iterator< boost::iterators::detail::iterator_category_with_traversal<Category, Traversal> >
{
 static const bool value = true;
};

template<class I, class R = void>
struct iterator_enable_if_boost_iterator
 : ::boost::move_detail::enable_if_c
 < is_boost_iterator<typename boost::intrusive::iterator_traits::iterator_category >::value
 , R>
{};

////////////////////////////////////////
// iterator_[dis|en]able_if_tag
////////////////////////////////////////
template<class I, class Tag, class R = void>
struct iterator_enable_if_tag
 : ::boost::move_detail::enable_if_c
 < ::boost::move_detail::is_same
 < typename boost::intrusive::iterator_traits::iterator_category 
 , Tag
 >::value
 , R>
{};

template<class I, class Tag, class R = void>
struct iterator_disable_if_tag
 : ::boost::move_detail::enable_if_c
 < !::boost::move_detail::is_same
 < typename boost::intrusive::iterator_traits::iterator_category 
 , Tag
 >::value
 , R>
{};

////////////////////////////////////////
// iterator_[dis|en]able_if_tag
////////////////////////////////////////
template<class I, class Tag, class Tag2, class R = void>
struct iterator_enable_if_convertible_tag
 : ::boost::move_detail::enable_if_c
 < ::boost::move_detail::is_same_or_convertible
 < typename boost::intrusive::iterator_traits::iterator_category 
 , Tag
 >::value &&
 !::boost::move_detail::is_same_or_convertible
 < typename boost::intrusive::iterator_traits::iterator_category 
 , Tag2
 >::value
 , R>
{};

////////////////////////////////////////
// iterator_[dis|en]able_if_tag_difference_type
////////////////////////////////////////
template<class I, class Tag>
struct iterator_enable_if_tag_difference_type
 : iterator_enable_if_tag<I, Tag, typename boost::intrusive::iterator_traits::difference_type>
{};

template<class I, class Tag>
struct iterator_disable_if_tag_difference_type
 : iterator_disable_if_tag<I, Tag, typename boost::intrusive::iterator_traits::difference_type>
{};

////////////////////
//    advance
////////////////////

template<class InputIt, class Distance>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
 iterator_advance(InputIt& it, Distance n)
{
 while(n--)
 ++it;
}

template<class InputIt, class Distance>
typename iterator_enable_if_tag<InputIt, std::forward_iterator_tag>::type
 iterator_advance(InputIt& it, Distance n)
{
 while(n--)
 ++it;
}

template<class InputIt, class Distance>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
 iterator_advance(InputIt& it, Distance n)
{
 for (; 0 < n; --n)
 ++it;
 for (; n < 0; ++n)
 --it;
}

template<class InputIt, class Distance>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag>::type
 iterator_advance(InputIt& it, Distance n)
{
 it += n;
}

template<class InputIt, class Distance>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
 <InputIt, const boost::iterators::incrementable_traversal_tag&, const boost::iterators::single_pass_traversal_tag&>::type
 iterator_advance(InputIt& it, Distance n)
{
 while(n--)
 ++it;
}

template<class InputIt, class Distance>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
 <InputIt, const boost::iterators::single_pass_traversal_tag &, const boost::iterators::forward_traversal_tag&>::type
 iterator_advance(InputIt& it, Distance n)
{
 while(n--)
 ++it;
}

template<class InputIt, class Distance>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
 <InputIt, const boost::iterators::forward_traversal_tag&, const boost::iterators::bidirectional_traversal_tag&>::type
 iterator_advance(InputIt& it, Distance n)
{
 while(n--)
 ++it;
}

template<class InputIt, class Distance>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
 <InputIt, const boost::iterators::bidirectional_traversal_tag&, const boost::iterators::random_access_traversal_tag&>::type
 iterator_advance(InputIt& it, Distance n)
{
 for (; 0 < n; --n)
 ++it;
 for (; n < 0; ++n)
 --it;
}

class fake{};

template<class InputIt, class Distance>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
 <InputIt, const boost::iterators::random_access_traversal_tag&, const fake&>::type
 iterator_advance(InputIt& it, Distance n)
{
 it += n;
}

////////////////////
// distance
////////////////////
template<class InputIt> inline
typename iterator_disable_if_tag_difference_type
 <InputIt, std::random_access_iterator_tag>::type
 iterator_distance(InputIt first, InputIt last)
{
 typename iterator_traits<InputIt>::difference_type off = 0;
 while(first != last){
 ++off;
 ++first;
 }
 return off;
}

template<class InputIt>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag_difference_type
 <InputIt, std::random_access_iterator_tag>::type
 iterator_distance(InputIt first, InputIt last)
{
 typename iterator_traits<InputIt>::difference_type off = last - first;
 return off;
}

template<class I>
BOOST_INTRUSIVE_FORCEINLINE typename iterator_traits::pointer iterator_arrow_result(const I &i)
{ return i.operator->(); }

template<class T>
BOOST_INTRUSIVE_FORCEINLINE T * iterator_arrow_result(T *p)
{ return p; }

} //namespace intrusive
} //namespace boost

#endif //BOOST_INTRUSIVE_DETAIL_ITERATOR_HPP

cmd: