GraphVisitorRange.h

 
#pragma once

 
#if defined(GraphVisitorRange_RECURSES)
#error Recursive header files inclusion detected in GraphVisitorRange.h
#else // defined(GraphVisitorRange_RECURSES)
#define GraphVisitorRange_RECURSES
 
#if !defined GraphVisitorRange_h
#define GraphVisitorRange_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/CountedPtr.h"
 
namespace DGtal
{

  // template class GraphVisitorRange
  template < typename TGraphVisitor >
  class GraphVisitorRange
  {
  public:
    typedef TGraphVisitor GraphVisitor;
    typedef typename GraphVisitor::Graph Graph;
    typedef typename GraphVisitor::Vertex Vertex;
    typedef typename GraphVisitor::Node Node;
    typedef typename GraphVisitor::Size Size;
    typedef typename GraphVisitor::Data Data;

    struct NodeAccessor {
      typedef const Node value;
      typedef const Node value_type;
      typedef const Node* pointer;
      typedef const Node& reference;
      inline
      static reference get( const Node & node )
      { return node; }
    };

    struct VertexAccessor {
      typedef const Vertex value;
      typedef const Vertex value_type;
      typedef const Vertex* pointer;
      typedef const Vertex& reference;
      inline
      static reference get( const Node & node )
      { return node.first; }
    };

    template <typename TAccessor>
    struct GenericConstIterator
    {
      typedef GenericConstIterator<TAccessor> Self;
      typedef TAccessor Accessor;
 
      // stl iterator types.
      typedef std::input_iterator_tag iterator_category;
      typedef typename Accessor::value value_type;
      typedef std::ptrdiff_t difference_type;
      typedef typename Accessor::pointer pointer;
      typedef typename Accessor::reference reference;

      CountedPtr< GraphVisitor > myVisitor;
 
      inline
      GenericConstIterator()
        : myVisitor( 0 ) {}
      inline
      GenericConstIterator( CountedPtr<GraphVisitor> ptrV )
        : myVisitor( ptrV ) {}
      inline
      GenericConstIterator( const Self & other )
        : myVisitor( other.myVisitor ) {}
 
      inline
      Self & operator=( const Self & other )
      {
        if ( this != &other )
          myVisitor = other.myVisitor;
        return *this;
      }
 
      inline
      reference
      operator*() const
      {
        ASSERT( ( myVisitor.get() != 0 )
                && "DGtal::GraphVisitorRange<>::GenericConstIterator<>::operator*(): you cannot dereferenced a null visitor (i.e. end()).");
        return Accessor::get( myVisitor->current() );
      }
 
      inline
      pointer
      operator->() const
      {
        ASSERT( ( myVisitor.get() != 0 )
                && "DGtal::GraphVisitorRange<>::GenericConstIterator<>::operator->(): you cannot dereferenced a null visitor (i.e. end()).");
        return & Accessor::get( operator*() );
      }
 
      inline
      Self&
      operator++()
      {
        myVisitor->expand();
        return *this;
      }
 
      inline
      Self
      operator++(int)
      {
        Self __tmp = *this;
        myVisitor->expand();
        return __tmp;
      }
 
      inline
      bool operator==( const Self & other ) const
      {
        if ( ( myVisitor.get() == 0 ) || myVisitor->finished() )
          return ( other.myVisitor.get() == 0 ) || other.myVisitor->finished();
        else if ( other.myVisitor.get() == 0 )
          return false;
        else
          return &(myVisitor->current()) == &(other.myVisitor->current());
      }
 
      inline
      bool operator!=( const Self & other ) const
      {
        return ! ( this->operator==( other ) );
      }
    };

    typedef GenericConstIterator<VertexAccessor> VertexConstIterator;
    typedef GenericConstIterator<NodeAccessor> NodeConstIterator;
 
    typedef VertexConstIterator ConstIterator;
    typedef ConstIterator const_iterator;
 
    // ----------------------- Standard services ------------------------------
  public:

    ~GraphVisitorRange();

    GraphVisitorRange( GraphVisitor* visitorPtr );

    ConstIterator begin() const;

    ConstIterator end() const;

    NodeConstIterator beginNode() const;

    NodeConstIterator endNode() const;
 
    // ----------------------- Interface --------------------------------------
  public:

    void selfDisplay ( std::ostream & out ) const;

    bool isValid() const;
 
    // ------------------------- Protected Data ------------------------------
  private:
    // ------------------------- Private Data --------------------------------
  private:

    CountedPtr<GraphVisitor> myVisitor;
 
    // ------------------------- Hidden services ------------------------------
  protected:

    GraphVisitorRange();
 
  private:

    GraphVisitorRange ( const GraphVisitorRange & other );

    GraphVisitorRange & operator= ( const GraphVisitorRange & other );
 
    // ------------------------- Internals ------------------------------------
  private:
 
  }; // end of class GraphVisitorRange
 

  template <typename TGraphVisitor>
  std::ostream&
  operator<< ( std::ostream & out, const GraphVisitorRange<TGraphVisitor> & object );
 
} // namespace DGtal
 

// Includes inline functions.
#include "DGtal/graph/GraphVisitorRange.ih"
 
//                                                                           //
 
#endif // !defined GraphVisitorRange_h
 
#undef GraphVisitorRange_RECURSES
#endif // else defined(GraphVisitorRange_RECURSES)