EdgeIterator.h

// -*- C++ -*-

#if !defined(__geom_mesh_simplicial_EdgeIterator_h__)
#define __geom_mesh_simplicial_EdgeIterator_h__

#if defined(DEBUG_geom) && !defined(DEBUG_EdgeIterator)
#define DEBUG_EdgeIterator
#endif


BEGIN_NAMESPACE_GEOM

template<class _Mesh, bool Const = true>
class 
EdgeIterator :
  public std::iterator< 
  // Iterator tag.
  std::bidirectional_iterator_tag,
  // Value type.
  typename 
  Loki::Select<Const, typename _Mesh::ConstEdge,
               typename _Mesh::Edge>::Result,
  // Pointer difference type.
  std::ptrdiff_t, 
  // Pointer type.
  typename 
  Loki::Select<Const, const typename _Mesh::ConstEdge*,
               typename _Mesh::Edge*>::Result,
  // Reference type.
  typename 
  Loki::Select<Const, const typename _Mesh::ConstEdge&,
               typename _Mesh::Edge&>::Result> {
  //
  // Enumerations.
  //

private:

  enum {M = _Mesh::M};

  //
  // Private types.
  //

private:

  typedef std::iterator< 
    // Iterator tag.
    std::bidirectional_iterator_tag,
    // Value type.
    typename 
    Loki::Select<Const, typename _Mesh::ConstEdge,
                 typename _Mesh::Edge>::Result,
    // Pointer difference type.
    std::ptrdiff_t, 
    // Pointer type.
    typename 
    Loki::Select<Const, const typename _Mesh::ConstEdge*,
                 typename _Mesh::Edge*>::Result,
    // Reference type.
    typename 
    Loki::Select<Const, const typename _Mesh::ConstEdge&,
                 typename _Mesh::Edge&>::Result> 
  Base;

  typedef _Mesh Mesh;
  typedef typename Mesh::Node Node;
  typedef typename Loki::Select<Const,
                                typename Mesh::NodeConstIterator,
                                typename Mesh::NodeIterator>::Result
  NodeIterator;

  typedef 
  typename Loki::Select<Const,
                        typename Node::CellIncidentToNodeConstIterator,
                        typename Node::CellIncidentToNodeIterator>::Result
  CellIncidentToNodeIterator;

  //
  // Public types.
  //

public:

  typedef typename Base::iterator_category iterator_category;
  typedef typename Base::value_type value_type;
  typedef typename Base::difference_type difference_type;
  typedef typename Base::pointer pointer;
  typedef typename Base::reference reference;

  typedef value_type Edge;
  typedef typename Loki::Select<Const,
                                typename Mesh::CellConstIterator,
                                typename Mesh::CellIterator>::Result
  CellIterator;

  //
  // Member data.
  //

private:
  
  Edge _edge;
  CellIterator _cellsEnd;

  //
  // Not implemented.
  //

private:

  EdgeIterator();

public:

  //--------------------------------------------------------------------------


  EdgeIterator(const CellIterator c, const CellIterator cellsEnd) :
    Base(),
    _edge(c, 0, 1),
    _cellsEnd(cellsEnd) {
    if (c != cellsEnd && ! isValid()) {
      increment();
    }
  }


public:

  //--------------------------------------------------------------------------


  EdgeIterator(const EdgeIterator& other) :
    Base(),
    _edge(other._edge),
    _cellsEnd(other._cellsEnd)
  {}    

  EdgeIterator&
  operator=(const EdgeIterator& other) {
    if (&other != this) {
      _edge = other._edge;
      _cellsEnd = other._cellsEnd;
    }
    return *this;
  }

  ~EdgeIterator()
  {}


  const Edge&
  getEdge() const {
    return _edge;
  }


  const CellIterator&
  getCellsEnd() const {
    return _cellsEnd;
  }

  template<bool _Const>
  EdgeIterator(const EdgeIterator<Mesh,_Const>& other) :
    Base(),
    _edge(other.getEdge()),
    _cellsEnd(other.getCellsEnd())
  {}    

  //--------------------------------------------------------------------------


  reference
  operator*() const {
    // Return a constant reference to the edge.
    return _edge;
  }

  pointer
  operator->() const {
    // Return a constant pointer to the edge.
    return &_edge;
  }
  
  EdgeIterator&
  operator++() { 
    increment();
    return *this; 
  }
      

  EdgeIterator
  operator++(int) {
    EdgeIterator x(*this); 
    ++*this;
    return x;
  }
      
  //--------------------------------------------------------------------------


  EdgeIterator&
  operator--() { 
    decrement();
    return *this; 
  }
      

  EdgeIterator
  operator--(int) {
    EdgeIterator x(*this); 
    --*this;
    return x;
  }

  //--------------------------------------------------------------------------

      
  //
  // Forward iterator requirements
  //

  bool
  operator==(const EdgeIterator& x) {
#ifdef DEBUG_EdgeIterator
    // These must be iterators over the same mesh.
    assert(_cellsEnd == x._cellsEnd);
#endif
    return _edge == x._edge;
  }

  bool
  operator!=(const EdgeIterator& x) {
    return ! operator==(x);
  }



private:

  // If the address of this cell is less than the addresses of the other
  // cells incident to the edge.
  bool
  isValid() {
    if (_edge.first != _cellsEnd) {
      // The source node of the edge.
      NodeIterator a = _edge.first->getNode(_edge.second);
      // The target node of the edge.
      NodeIterator b = _edge.first->getNode(_edge.third);
      // For each incident cell of the source node.
      for (CellIncidentToNodeIterator c = a->getCellsBeginning(); 
           c != a->getCellsEnd(); ++c) {
        // If this cell is incident to the edge and its identifier is less 
        // than this cell's identifier.
        if (c->hasNode(b) && 
            c->getIdentifier() < _edge.first->getIdentifier()) {
          return false;
        }
      }
    }
    return true;
  }

  // Increment the iterator.
  void
  increment() {
    // While we have not gone through all of the cells.
    while (_edge.first != _cellsEnd) {
      // Go to the next edge.
      ++_edge.third;
      if (_edge.third == M + 1) {
        ++_edge.second;
        _edge.third = _edge.second + 1;
      }
      if (_edge.second == M) {
        ++_edge.first;
        _edge.second = 0;
        _edge.third = 1;
      }
      // If this edge is valid.
      if (isValid()) {
        // Then we have a edge.  Break out of the loop and return.
        break;
      }
    }
  }

  // Decrement the iterator.
  void
  decrement() {
    // While we have not gone through all of the cells.
    do {
      // Go to the previous edge.
      --_edge.third;
      if (_edge.third == _edge.second) {
        --_edge.second;
        _edge.third = M;
      }
      if (_edge.second == -1) {
        --_edge.first;
        _edge.second = M-1;
        _edge.third = M;
      }
      // If this edge is valid.
      if (isValid()) {
        // Then we have a edge.  Break out of the loop and return.
        break;
      }
    } while (_edge.first != _cellsEnd);
  }

};

END_NAMESPACE_GEOM

#endif

---