IteratorFunctions.h

 
#pragma once

 
#if defined(IteratorFunctions_RECURSES)
#error Recursive header files inclusion detected in IteratorFunctions.h
#else // defined(IteratorFunctions_RECURSES)
#define IteratorFunctions_RECURSES
 
#if !defined IteratorFunctions_h
#define IteratorFunctions_h

// Inclusions
#include<iterator>
#include "DGtal/base/IteratorCirculatorTraits.h"
 
namespace DGtal
{

  // template functions isNotEmpty
 
  namespace detail
  {

    template< typename IC >
    inline
    bool isNotEmpty( const IC& itb, const IC& ite, IteratorType );

    template< typename IC >
    inline
    bool isNotEmpty( const IC& c1, const IC& c2, CirculatorType);
 
  } //end namespace detail

  template< typename IC>
  inline
  bool isEmpty( const IC& itb, const IC& ite );

  template< typename IC>
  inline
  bool isNotEmpty( const IC& itb, const IC& ite );

  // template functions for the size and middle of a (sub)range

  template<typename IC>
  inline
  void advanceIterator(IC& ic,
                       typename IteratorCirculatorTraits<IC>::Difference n);
 
  namespace detail
  {
    template<typename IC>
    inline
    void advanceIterator(IC& ic,
                         typename IteratorCirculatorTraits<IC>::Difference n,
                         ForwardCategory /*c*/);

    template<typename IC>
    inline
    void advanceIterator(IC& ic,
                         typename IteratorCirculatorTraits<IC>::Difference n,
                         RandomAccessCategory /*c*/);
  } //end namespace detail

  template<typename IC>
  inline
  typename IteratorCirculatorTraits<IC>::Difference
  rangeSize(const IC& itb, const IC& ite);

  template<typename IC>
  inline
  typename IteratorCirculatorTraits<IC>::Difference
  subRangeSize(const IC& itb, const IC& ite);
 
  namespace detail
  {
    template<typename I>
    inline
    typename IteratorCirculatorTraits<I>::Difference
    rangeSize(const I& itb, const I& ite, IteratorType /*t*/, ForwardCategory /*c*/);

    template<typename C>
    inline
    typename IteratorCirculatorTraits<C>::Difference
    rangeSize(const C& cb, const C& ce, CirculatorType /*t*/, ForwardCategory /*c*/);

    template<typename I>
    inline
    typename IteratorCirculatorTraits<I>::Difference
    rangeSize(const I& itb, const I& ite, IteratorType /*t*/, RandomAccessCategory /*c*/);

    template<typename C>
    inline
    typename IteratorCirculatorTraits<C>::Difference
    rangeSize(const C& cb, const C& ce, CirculatorType /*t*/, RandomAccessCategory /*c*/);
 
  } //namespace detail

  template<typename IC>
  inline
  IC rangeMiddle(const IC& itb, const IC& ite);

  template<typename IC>
  inline
  IC subRangeMiddle(const IC& itb, const IC& ite);
 
  namespace detail
  {
    template<typename I>
    inline
    I rangeMiddle(const I& itb, const I& ite, IteratorType /*t*/, ForwardCategory /*c*/);

    template<typename C>
    inline
    C rangeMiddle(const C& cb, const C& ce, CirculatorType /*t*/, ForwardCategory /*c*/);

    template<typename I>
    inline
    I rangeMiddle(const I& itb, const I& ite, IteratorType /*t*/, BidirectionalCategory /*c*/);

    template<typename C>
    inline
    C rangeMiddle(const C& cb, const C& ce, CirculatorType /*t*/, BidirectionalCategory /*c*/);

    template<typename I>
    inline
    I rangeMiddle(const I& itb, const I& ite, IteratorType /*t*/, RandomAccessCategory /*c*/);

    template<typename C>
    inline
    C rangeMiddle(const C& cb, const C& ce, CirculatorType /*t*/, RandomAccessCategory /*c*/);
  } // namespace namespace
 
 
} // namespace DGtal
 
 
 

// Includes inline functions.
#include "DGtal/base/IteratorFunctions.ih"
 
//                                                                           //
 
#endif // !defined IteratorFunctions_h
 
#undef IteratorFunctions_RECURSES
#endif // else defined(IteratorFunctions_RECURSES)