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)