SimplexIterator.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_mesh_iss_SimplexIterator_h__)
#define __geom_mesh_iss_SimplexIterator_h__

// If we are debugging the whole geom package.
#if defined(DEBUG_geom) && !defined(DEBUG_SimplexIterator)
#define DEBUG_SimplexIterator
#endif

#include <iterator>

BEGIN_NAMESPACE_GEOM


// CONTINUE: Make this a nested class.  It is only used through the 
// IndSimpSet::simplex_const_iterator type.


template<class ISS>
class SimplexIterator :
  public std::iterator<std::random_access_iterator_tag,
                       typename ISS::Simplex,
                       std::ptrdiff_t,
                       const typename ISS::Simplex*,
                       const typename ISS::Simplex&> {
  //
  // Private types.
  //

private:
  
  typedef std::iterator<std::random_access_iterator_tag,
                        typename ISS::Simplex,
                        std::ptrdiff_t,
                        const typename ISS::Simplex*,
                        const typename ISS::Simplex&> 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 ISS IssType;

  //
  // Member data.
  //

private:

  int _index;
  mutable value_type _simplex;
  const IssType& _iss;

  //
  // Not implemented.
  //

private:

  // Default constructor not implemented.
  SimplexIterator();

public:

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



  SimplexIterator(const IssType& iss) :
    Base(),
    _index(0),
    _simplex(),
    _iss(iss)
  {}

  SimplexIterator(const SimplexIterator& other) :
    Base(),
    _index(other._index),
    _simplex(),
    _iss(other._iss)
  {}    

  SimplexIterator&
  operator=(const SimplexIterator& other)
  {
    if (&other != this) {
      _index = other._index;
    }
    return *this;
  }

  ~SimplexIterator()
  {}

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


  reference
  operator*() const {
    // Update the simplex.
    update(_index);
    // Then return a constant reference to it.
    return _simplex;
  }

  pointer
  operator->() const {
    // Update the simplex.
    update(_index);
    // Then return a constant reference to it.
    return &_simplex;
  }

  SimplexIterator&
  operator++() { 
    ++_index; 
    return *this; 
  }
      

  SimplexIterator
  operator++(int) {
    SimplexIterator x(*this); 
    ++*this;
    return x;
  }

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


  SimplexIterator&
  operator--() { 
    --_index; 
    return *this; 
  }
      

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


  reference
  operator[](const difference_type n) const { 
    // Update the simplex with the requested offset value.
    update(_index + n);
    // Then return a constant reference to it.
    return _simplex;
  }
  
  SimplexIterator&
  operator+=(const difference_type n) { 
    _index += n; 
    return *this; 
  }


  SimplexIterator
  operator+(const difference_type n) const { 
    SimplexIterator x(*this); 
    x += n;
    return x;
  }
      
  SimplexIterator&
  operator-=(const difference_type n) { 
    _index -= n; 
    return *this; 
  }


  SimplexIterator
  operator-(const difference_type n) const { 
    SimplexIterator x(*this); 
    x -= n;
    return x;
  }

  int
  getBase() const {
    return _index;
  }


  //
  // Private member functions
  //

private:

  // Update the simplex for the current index.
  void
  update(const int index) const {
    for (int m = 0; m != IssType::M + 1; ++m) {
      _simplex[m] = _iss.getSimplexVertex(index, m);
    }
  }
};


//
// Forward iterator requirements
//


template<class ISS>
inline 
bool
operator==(const SimplexIterator<ISS>& x, const SimplexIterator<ISS>& y) { 
  return x.getBase() == y.getBase(); 
}


template<class ISS>
inline 
bool
operator!=(const SimplexIterator<ISS>& x, const SimplexIterator<ISS>& y) { 
  return !(x == y);
}


//
// Random access iterator requirements
//


template<class ISS>
inline 
bool 
operator<(const SimplexIterator<ISS>& x, const SimplexIterator<ISS>& y) { 
  return x.getBase() < y.getBase(); 
}


template<class ISS>
inline 
bool
operator>(const SimplexIterator<ISS>& x, const SimplexIterator<ISS>& y) { 
  return x.getBase() > y.getBase(); 
}


template<class ISS>
inline 
bool
operator<=(const SimplexIterator<ISS>& x, const SimplexIterator<ISS>& y) { 
  return x.getBase() <= y.getBase(); 
}


template<class ISS>
inline 
bool
operator>=(const SimplexIterator<ISS>& x, const SimplexIterator<ISS>& y) { 
  return x.getBase() >= y.getBase(); 
}


template<class ISS>
inline 
typename SimplexIterator<ISS>::difference_type
operator-(const SimplexIterator<ISS>& x, const SimplexIterator<ISS>& y) { 
  return x.getBase() - y.getBase(); 
}


template<class ISS>
inline 
SimplexIterator<ISS>
operator+(typename SimplexIterator<ISS>::difference_type n,
          const SimplexIterator<ISS>& i) { 
  SimplexIterator<ISS> x(i); 
  x += n;
  return x;
}

END_NAMESPACE_GEOM

#endif

---