IteratorTraits.h

#pragma once

#if defined(IteratorTraits_RECURSES)
#error Recursive header files inclusion detected in IteratorTraits.h
#else // defined(IteratorTraits_RECURSES)

#define IteratorTraits_RECURSES

#if !defined IteratorTraits_h

#define IteratorTraits_h

// Inclusions
#include<iterator>
#include<boost/iterator/iterator_categories.hpp>
#include<boost/iterator/iterator_facade.hpp>

namespace DGtal
{

// tag classes for type (either Iterator or Circulator)
struct IteratorType {};
struct CirculatorType {};

// tag classes for traversal category (Foward, Bidirectional, RandomAccess) 
// valid for both iterator and circulator
struct ForwardCategory {};
struct BidirectionalCategory : ForwardCategory {};
struct RandomAccessCategory : BidirectionalCategory {}; 

namespace detail
{ 


  template <typename IC> 
  struct HasNestedType 
  {
    typedef char yes[1]; 
    typedef char no[2]; 
    
    template <typename C>
    static yes& test(typename C::Type*);

    template <typename C>
    static no& test(...);

    static const bool value = sizeof(test<IC>(0)) == sizeof(yes); 
  };


  template <typename IC, bool flagHasNestedType = false> 
  struct IsCirculator 
  {
    static const bool value = false; 
  };

  template <typename IC> 
  struct IsCirculator<IC,true> 
  {
    //from en.wikipedia.org/wiki/Substitution_failure_is_not_an_error
    typedef char yes[1]; 
    typedef char no[2]; 
    
    static yes& test(CirculatorType);

    static no& test(IteratorType);

    static const bool value = ( sizeof(test(typename IC::Type())) == sizeof(yes) ); 
  };

} //namespace detail


template <typename IC> 
struct IsCirculator 
{
  static const bool value = detail::IsCirculator<IC, detail::HasNestedType<IC>::value >::value; 
};

namespace detail
{

  template<bool b = false>
  struct IteratorCirculatorTypeImpl 
  {
    typedef IteratorType Type; 
  };
  template<>
  struct IteratorCirculatorTypeImpl<true> 
  {
    typedef CirculatorType Type; 
  };
}//namespace detail


template<typename IC>
struct IteratorCirculatorType {
public: 
  typedef typename detail::IteratorCirculatorTypeImpl<IsCirculator<IC>::value >::Type Type; 
};


//default
template <typename C>
struct IteratorCirculatorTagTraits {
    typedef  C  Category;
};

//for STL iterators
template <>
struct IteratorCirculatorTagTraits<std::forward_iterator_tag> {
    typedef  ForwardCategory Category;
};

template <>
struct IteratorCirculatorTagTraits<std::bidirectional_iterator_tag> {
    typedef  BidirectionalCategory Category;
};

template <>
struct IteratorCirculatorTagTraits<std::random_access_iterator_tag> {
    typedef  RandomAccessCategory Category;
};

//for boost traversal categories
template <>
struct IteratorCirculatorTagTraits<boost::forward_traversal_tag> {
    typedef  ForwardCategory Category;
};

template <>
struct IteratorCirculatorTagTraits<boost::bidirectional_traversal_tag> {
    typedef  BidirectionalCategory Category;
};

template <>
struct IteratorCirculatorTagTraits<boost::random_access_traversal_tag> {
    typedef  RandomAccessCategory Category;
};

template <>
struct IteratorCirculatorTagTraits<boost::detail::iterator_category_with_traversal<std::input_iterator_tag,boost::forward_traversal_tag> > {
    typedef  ForwardCategory Category;
};

template <>
struct IteratorCirculatorTagTraits<boost::detail::iterator_category_with_traversal<std::input_iterator_tag,boost::bidirectional_traversal_tag> > {
    typedef  BidirectionalCategory Category;
};

template <>
struct IteratorCirculatorTagTraits<boost::detail::iterator_category_with_traversal<std::input_iterator_tag,boost::random_access_traversal_tag> > {
    typedef  RandomAccessCategory Category;
};





template <typename IC>
struct IteratorCirculatorTraits {

  typedef typename IteratorCirculatorType<IC>::Type
                                                                 Type;

  typedef typename IteratorCirculatorTagTraits
  <typename boost::iterator_category<IC>::type>::Category
                                                                 Category;

  typedef typename IC::value_type                                Value;
  typedef typename IC::difference_type                           Difference;
  typedef typename IC::pointer                                   Pointer;
  typedef typename IC::reference                                 Reference;

};

template <class T>
struct IteratorCirculatorTraits<T*> {
  typedef IteratorType               Type; 
  typedef RandomAccessCategory       Category;
  typedef T                          Value;
  typedef ptrdiff_t                  Difference;
  typedef T*                         Pointer;
  typedef T&                         Reference;
};

template <class T>
struct IteratorCirculatorTraits<T const*>
{
  typedef IteratorType               Type; 
  typedef RandomAccessCategory       Category;
  typedef T                          Value;
  typedef ptrdiff_t                  Difference;
  typedef T const*                   Pointer;
  typedef T const&                   Reference;
};

} // namespace DGtal


// Includes inline functions.
//#include "DGtal/base/IteratorTraits.ih"

//                                                                           //

#endif // !defined IteratorTraits_h

#undef IteratorTraits_RECURSES
#endif // else defined(IteratorTraits_RECURSES)