PlayaBlockIteratorDecl.hpp

/* @HEADER@ */
//   
/* @HEADER@ */

#ifndef PLAYA_BLOCKITERATORDECL_HPP
#define PLAYA_BLOCKITERATORDECL_HPP

#include "PlayaDefs.hpp"
#include "Teuchos_Array.hpp"
#include <deque> 

namespace Playa
{

using Teuchos::RCP;
using Teuchos::Array;

/* Forward declare VectorSpaceBase */
template <class Scalar> 
class VectorSpaceBase;

/* Forward declare VectorSpace */
template <class Scalar> 
class VectorSpace;

/* Forward declare Vector */
template <class Scalar> 
class Vector;


template <class Scalar>
class BlockIterator
{
public:

  friend class VectorSpaceBase<Scalar>;
  friend class VectorSpace<Scalar>;
  friend class Vector<Scalar>;

  BlockIterator() : space_(),
                    index_(), 
                    atEnd_(true){}

  bool operator==(const BlockIterator<Scalar>& other) const ;

  bool operator!=(const BlockIterator<Scalar>& other) const 
    {
      return !operator==(other);
    }

  bool operator<(const BlockIterator<Scalar>& other) const ;

  BlockIterator<Scalar> operator++(int);

  const VectorSpace<Scalar>& space() const ;
  
  std::ostream& print(std::ostream& os) const ;

  const std::deque<int>& blockIndex() const {return index_;}

  bool atEnd() const {return atEnd_;}

  static bool& debug() 
    {static bool rtn = false; return rtn;}

protected:

  void goToStart(const VectorSpace<Scalar>& space,
    std::deque<int>& pos) const ;

  BlockIterator(const VectorSpace<Scalar>& space,
    bool atEnd);

  bool advance(int level);

private:
  RCP<const VectorSpace<Scalar> > space_;
  std::deque<int> index_;
  bool atEnd_;
};

}

namespace Playa
{
template <class Scalar> inline
std::ostream& operator<<(std::ostream& os, 
  const Playa::BlockIterator<Scalar>& i)
{
  return i.print(os);
}
}


#endif