ArrayImageIterator.h

 
#pragma once
 
#if defined(ArrayImageIterator_RECURSES)
#error Recursive header files inclusion detected in ArrayImageIterator.h
#else // defined(ArrayImageIterator_RECURSES)
#define ArrayImageIterator_RECURSES
 
#if !defined ArrayImageIterator_h
#define ArrayImageIterator_h
 
// Inclusions
#include <ostream>
#include <type_traits>
#include <boost/iterator/iterator_facade.hpp>
#include <DGtal/kernel/domains/Linearizer.h>
 
namespace DGtal
{
 
 
  template <
    typename TIterableClass
  >
  class ArrayImageIterator
    : public boost::iterator_facade <
        ArrayImageIterator<TIterableClass>,
        typename TIterableClass::Value,
        std::random_access_iterator_tag,
        decltype( ((new TIterableClass))->dereference( TIterableClass::Point::diagonal(0), typename TIterableClass::Point::Coordinate(0) ) )
      >
    {
    // ----------------------- Standard services ------------------------------
    public:
 
      // Typedefs
      using Self = ArrayImageIterator<TIterableClass>;  
      using IterableClass = TIterableClass;             
      using Domain = typename IterableClass::Domain;    
      using Point = typename Domain::Point;             
      using Linearizer = DGtal::Linearizer<Domain, ColMajorStorage>; 
      using Reference = decltype( ((new IterableClass)->dereference( Point::diagonal(0), typename Point::Coordinate(0) ) )); 
 
      ArrayImageIterator();
 
      ArrayImageIterator( IterableClass* anIterableClassPtr, Domain const& aFullDomain, Domain const& aViewDomain, Point const& aPoint );
 
      ArrayImageIterator( IterableClass* anIterableClassPtr, Domain const& aFullDomain, Domain const& aViewDomain );
 
      ArrayImageIterator( IterableClass* anIterableClassPtr, Domain const& aFullDomain );
 
      ArrayImageIterator( IterableClass* anIterableClassPtr, Domain const& aFullDomain, Domain const& aViewDomain, bool /* last */ );
 
      ArrayImageIterator( IterableClass* anIterableClassPtr, Domain const& aFullDomain, bool /* last */ );
 
      template < typename TOtherIterableClass >
      ArrayImageIterator(
          ArrayImageIterator<TOtherIterableClass> const& other,
          typename std::enable_if< std::is_convertible<TOtherIterableClass*, IterableClass*>::value >::type* = 0
      );
 
      template < typename TOtherIterableClass >
      ArrayImageIterator(
          ArrayImageIterator<TOtherIterableClass> && other,
          typename std::enable_if< std::is_convertible<TOtherIterableClass*, IterableClass*>::value >::type* = 0
      ) noexcept;
 
      ~ArrayImageIterator();
 
      template < typename TOtherIterableClass >
      typename std::enable_if<
          std::is_convertible<TOtherIterableClass*, IterableClass*>::value,
          Self& >::type
      operator= (
          ArrayImageIterator<TOtherIterableClass> const& other
      );
 
      template < typename TOtherIterableClass >
      typename std::enable_if<
          std::is_convertible<TOtherIterableClass*, IterableClass*>::value,
          Self& >::type
      operator= (
          ArrayImageIterator<TOtherIterableClass> && other
      );
 
 
      // ----------------------- Interface --------------------------------------
    public:
 
      inline Point const& getPoint() const noexcept;
 
      inline
      std::ptrdiff_t distance_to( Point const& aPoint ) const noexcept;
 
      void selfDisplay ( std::ostream & out ) const;
 
      bool isValid() const;
 
    // ------------------------- Private Datas --------------------------------
    private:
      IterableClass* myIterableClassPtr; 
      Domain myFullDomain;  
      Domain myViewDomain;  
      Point myFullExtent;   
      Point myViewExtent;   
      Point myPoint;        
      typename Point::Coordinate myFullIndex; 
 
      // ------------------------- Hidden services ------------------------------
    private:
 
      // Friendship
      template <class> friend class ArrayImageIterator; 
      friend class boost::iterator_core_access; 
 
      void increment();
 
      void decrement();
 
      inline
      bool equal( Self const& other ) const;
 
      inline
      Reference dereference() const;
 
      inline
      std::ptrdiff_t distance_to( Self const& other ) const ;
 
      void advance( std::ptrdiff_t n );
 
    }; // end of class ArrayImageIterator
 
 
  template <typename TIterableClass>
  std::ostream&
  operator<< ( std::ostream & out, const ArrayImageIterator<TIterableClass> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/images/ArrayImageIterator.ih"
 
//                                                                           //
 
#endif // !defined ArrayImageIterator_h
 
#undef ArrayImageIterator_RECURSES
#endif // else defined(ArrayImageIterator_RECURSES)