File Coverage

/usr/local/lib/perl5/site_perl/5.26.1/XS/libboost/mini.x/i/boost/intrusive/detail/iterator.hpp

Criterion	Covered	Total	%
statement	2	2	100.0
branch			n/a
condition			n/a
subroutine			n/a
pod			n/a
total	2	2	100.0

/////////////////////////////////////////////////////////////////////////////
//
// (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
#endif

#if defined(BOOST_HAS_PRAGMA_ONCE)
#  pragma once
#endif

#include
#include
#include
#include
#include

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
struct iterator_category_with_traversal;

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

namespace boost {
namespace intrusive {

using boost::movelib::iterator_traits;

////////////////////
//    iterator
////////////////////
template
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
struct is_boost_iterator
{
   static const bool value = false;
};

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

template
struct iterator_enable_if_boost_iterator
   : ::boost::move_detail::enable_if_c
      < is_boost_iterator::iterator_category >::value
      , R>
{};

////////////////////////////////////////
//    iterator_[dis|en]able_if_tag
////////////////////////////////////////
template
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
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
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
struct iterator_enable_if_tag_difference_type
   : iterator_enable_if_tag::difference_type>
{};

template
struct iterator_disable_if_tag_difference_type
   : iterator_disable_if_tag::difference_type>
{};

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

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

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

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

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

template
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
   ::type
   iterator_advance(InputIt& it, Distance n)
{
   while(n--)
	   ++it;
}

template
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
   ::type
   iterator_advance(InputIt& it, Distance n)
{
   while(n--)
	   ++it;
}

template
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
   ::type
   iterator_advance(InputIt& it, Distance n)
{
   while(n--)
	   ++it;
}

template
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
   ::type
   iterator_advance(InputIt& it, Distance n)
{
   for (; 0 < n; --n)
	   ++it;
   for (; n < 0; ++n)
	   --it;
}

class fake{};

template
BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
   ::type
   iterator_advance(InputIt& it, Distance n)
{
   it += n;
}

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

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

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

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

} //namespace intrusive
} //namespace boost

#endif //BOOST_INTRUSIVE_DETAIL_ITERATOR_HPP