toolbox/coeffIterator.hh

Go to the documentation of this file.

/* iterator over array of coefficients
 */

#ifndef coeffIterator_hh
#define coeffIterator_hh

#include "basics/typedefs.hh"
#include "basics/exceptions.hh"
#include "basics/vectorsMatrices.hh"
#include "basics/debug.hh"

// debugging
#define CoeffItIncrOp_D 0

namespace concepts {

  // ********************************************************* CoeffIterator **

  template<typename F, typename Coeff>
  class CoeffIterator;

  template<typename F>
  class CoeffIterator<F, F> {
  public:
    CoeffIterator(const F* data) : data_(data) {}
    const F* operator++() { return ++data_; }
    inline const F* operator++(int) { return data_++; }
  private:
    const F* data_;
  };

  template<typename F, int dim>
  class CoeffIterator<F, Point<F,dim> >
  {
  public:
    CoeffIterator(const Point<F,dim>* data, int i = 0) : data_(data), i_(i) {}
    inline const F* operator++();
    inline const F* operator++(int);
    inline const F* data();
  private:
    const Point<F,dim>* data_;    
    const int i_;
  };

  template<typename F, int dim>
  const F* CoeffIterator<F, Point<F,dim> >::operator++()
  {
    ++data_;
    DEBUGL(CoeffItIncrOp_D, '(' << i_ << ") is "
           << *this->data() << " at " << this->data());
    return this->data();
  }

  template<typename F, int dim>
  const F* CoeffIterator<F, Point<F,dim> >::operator++(int)
  {
    const F* tmp = this->data();
    ++data_;
    return tmp;
  }

  template<typename F, int dim>
  const F* CoeffIterator<F, Point<F,dim> >::data()
  {
    return &(data_->operator[](i_));
  }

  template<typename F, int dim>
  class CoeffIterator<F, Mapping<F,dim> >
 {
  public:
    CoeffIterator(const Mapping<F,dim>* data, uint i = 0, uint j = 0) :
      data_(data), i_(i), j_(j) {}
    inline const F* operator++();
    inline const F* operator++(int);
    inline const F* data();
  private:
    const Mapping<F,dim>* data_;
    const uint i_;
    const uint j_;
  };

  template<typename F, int dim>
  const F* CoeffIterator<F, Mapping<F,dim> >::operator++()
  {
    ++data_;
    DEBUGL(CoeffItIncrOp_D, '(' << i_ << ", " << j_ << ") is "
           << *this->data() << " at " << this->data());
    return this->data();
  }

  template<typename F, int dim>
  const F* CoeffIterator<F, Mapping<F,dim> >::operator++(int)
  {
    const F* tmp = this->data();
    ++data_;
    return tmp;
  }

  template<typename F, int dim>
  const F* CoeffIterator<F, Mapping<F,dim> >::data()
  {
    return &(data_->operator()(i_, j_));
  }

} // namespace

#endif // coeffIterator_hh