IssiaFaceIterator.h

// -*- C++ -*-

#if !defined(__geom_mesh_iss_IssiaFaceIterator_h__)
#define __geom_mesh_iss_IssiaFaceIterator_h__

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


BEGIN_NAMESPACE_GEOM


template<class ISSIA>
class 
IssiaFaceIterator  :
  public std::iterator<std::bidirectional_iterator_tag, // Iterator tag.
                       std::pair<int,int>, // Value type.
                       std::ptrdiff_t, // Pointer difference type.
                       const std::pair<int,int>*, // Pointer type.
                       const std::pair<int,int>&> { // Reference type.
  //
  // Private types.
  //

private:

  typedef std::iterator<std::bidirectional_iterator_tag,
                        std::pair<int,int>,
                        std::ptrdiff_t,
                        const std::pair<int,int>*,
                        const std::pair<int,int>&> 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;

  //
  // Member data.
  //

private:
  
  const ISSIA* _mesh;
  value_type _face;

  //
  // Not implemented.
  //

private:

  IssiaFaceIterator();

public:

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


  IssiaFaceIterator(const ISSIA* mesh, const int simplexIndex) :
    Base(),
    _mesh(mesh),
    _face(simplexIndex, 0) {
    // We allow it to be equal to simplices_size for the past-the-end iterator.
    assert(0 <= simplexIndex && simplexIndex <= _mesh->getSimplicesSize());
    if (simplexIndex != _mesh->getSimplicesSize() && ! isValid()) {
      increment();
    }
  }


public:

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


  IssiaFaceIterator(const IssiaFaceIterator& other) :
    Base(),
    _mesh(other._mesh),
    _face(other._face)
  {}    

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

  ~IssiaFaceIterator()
  {}

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


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

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

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


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

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

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

      
  //
  // Forward iterator requirements
  //

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

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



private:

  // If there is no adjacent cell through the face or
  // if the address of this cell is less than the address of the 
  // adjacent cell through the face.
  bool
  isValid() {
    // The index of the adjacent neighbor.
    int neighbor = _mesh->getAdjacent(_face.first, _face.second);
    // Return true if there is no neighbor or if our index is less than 
    // the neighbor.
    return (neighbor == -1 || _face.first < neighbor);
  }

  // Increment the iterator.
  void
  increment() {
    assert(0 <= _face.first && _face.first < _mesh->getSimplicesSize());
    assert(0 <= _face.second && _face.second <= ISSIA::M);
    // While we have not gone through all of the cells.
    while (_face.first != _mesh->getSimplicesSize()) {
      // Advance to the next face.

      // If we have not gone through all the faces of this cell.
      if (_face.second != ISSIA::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 index of this cell is less than the index of the 
      // adjacent cell through the face.
      if (_face.first != _mesh->getSimplicesSize() && 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 != -1) {

      // 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 = ISSIA::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 index of this cell is less than the index of the 
      // adjacent cell through the face.
      if (_face.first != -1 && isValid()) {
        // Then we have a face.  Break out of the loop and return.
        break;
      }
    }
  }

};

END_NAMESPACE_GEOM

#endif

---