FaceIterator.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_mesh_simplicial_FaceIterator_h__)
#define __geom_mesh_simplicial_FaceIterator_h__

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


BEGIN_NAMESPACE_GEOM

template<int M, typename _Face, typename _CellHandle>
class 
FaceIterator  :
  public std::iterator<std::bidirectional_iterator_tag, // Iterator tag.
                       _Face, // Value type.
                       std::ptrdiff_t, // Pointer difference type.
                       const _Face*, // Pointer type.
                       const _Face&> { // Reference type. 
  //
  // Private types.
  //

private:

  typedef std::iterator<std::bidirectional_iterator_tag,
                        _Face,
                        std::ptrdiff_t,
                        const _Face*,
                        const _Face&> Base;
  
  //
  // 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 _Face Face;
  typedef _CellHandle CellHandle;

  //
  // Member data.
  //

private:
  
  Face _face;
  CellHandle _cellsEnd;

  //
  // Not implemented.
  //

private:

  FaceIterator();

public:

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


  FaceIterator(const CellHandle c, const CellHandle cellsEnd) :
    Base(),
    _face(c, 0),
    _cellsEnd(cellsEnd) {
    if (c != cellsEnd && ! isValid()) {
      increment();
    }
  }


public:

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


  FaceIterator(const FaceIterator& other) :
    Base(),
    _face(other._face),
    _cellsEnd(other._cellsEnd)
  {}    

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

  ~FaceIterator()
  {}


  const Face&
  getFace() const {
    return _face;
  }


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

  template<typename AnyFace, typename AnyCellHandle>
  FaceIterator(const FaceIterator<M, AnyFace, AnyCellHandle>& other) :
    Base(),
    _face(other.getFace()),
    _cellsEnd(other.getCellsEnd())
  {}    

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


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

  pointer
  operator->() const {
    // Return a constant pointer to the face.
    return &_face;
  }
  
  FaceIterator&
  operator++() { 
    increment();
    return *this; 
  }
      

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


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

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

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

      
  //
  // Forward iterator requirements
  //

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

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



private:

  // If there is no adjacent cell through the face or
  // if the identifier of this cell is less than the identifier of the 
  // adjacent cell through the face.
  bool
  isValid() {
    return (_face.first->getNeighbor(_face.second) == 0 || 
             _face.first->getIdentifier() < 
             _face.first->getNeighbor(_face.second)->getIdentifier());
  }

  // Increment the iterator.
  void
  increment() {
    // While we have not gone through all of the cells.
    while (_face.first != _cellsEnd) {

      // Advance to the next face.

      // If we have not gone through all the faces of this cell.
      if (_face.second != M) {
        // Advance to the next face within the cell.
        ++_face.second;
      }
      else {
        // Advance to the next cell.
        ++_face.first;
        _face.second = 0;
      }

      // First check that we have not gone through all of the cells.
      // If there is no adjacent cell through the face or
      // if the identifier of this cell is less than the identifier of the 
      // adjacent cell through the face.
      if (_face.first != _cellsEnd && isValid()) {
        // Then we have a face.  Break out of the loop and return.
        break;
      }
    }
  }

  // Decrement the iterator.
  void
  decrement() {
    // While we have not gone through all of the cells.
    while (_face.first != _cellsEnd) {

      // Move to the previous face.

      // If we have not gone through all the faces of this cell.
      if (_face.second != 0) {
        // Go to the previous face within the cell.
        --_face.second;
      }
      else {
        // Go to the previous cell.
        --_face.first;
        _face.second = M;
      }

      // First check that we have not gone through all of the cells.
      // If there is no adjacent cell through the face or
      // if the identifier of this cell is less than the identifier of the 
      // adjacent cell through the face.
      if (_face.first != _cellsEnd && isValid()) {
        // Then we have a face.  Break out of the loop and return.
        break;
      }
    }
  }

};

END_NAMESPACE_GEOM

#endif

---