space.hh

Go to the documentation of this file.

 
#ifndef aglowavSpace_hh
#define aglowavSpace_hh
 
#ifdef __GUNG__
  #pragma interface
#endif
 
#include "toolbox/scannerConnectors.hh"
#include "space/space.hh"
#include "aglowav/element.hh"
#include "aglowav/tree.hh"
#include "basics/output.hh"
 
namespace aglowav {
 
  // ********************************************************* Haar3dDFSScan **
 
  template<class F = concepts::Real>
  class Haar3dDFSScan : public concepts::Scan<concepts::Element<F> > {
  public:
    virtual Haar3dXXX<F>& operator++(int) = 0;
  };
 
 
  // ********************************************************* Haar3dBFSScan **
 
  template<class F = concepts::Real>
  class Haar3dBFSScan : public concepts::Scan<concepts::Element<F> > {
  public:
    virtual Haar3dXXX<F>& operator++(int) = 0;
    virtual void skip(uint lvl) = 0;
  };
 
  // **************************************************************** Haar3d **
 
  template<class F = concepts::Real>
  class Haar3d : public concepts::Space<F> {
  public:
    virtual ~Haar3d() {}
 
    virtual uint nlvl() const = 0;
    virtual Haar3dDFSScan<F>* dfsscan() const = 0;
    virtual Haar3dBFSScan<F>* bfsscan() const = 0;
  };
 
  // ******************************************************* BiHaar3dDFSScan **
 
  template<class F = concepts::Real>
  class BiHaar3dDFSScan : public Haar3dDFSScan<F> {
  public:
    BiHaar3dDFSScan(Haar3d000<F>* elm, uint ht);
    BiHaar3dDFSScan(const BiHaar3dDFSScan<F>& sc);
    inline ~BiHaar3dDFSScan() {delete[] stk_;}
 
    Haar3d000<F>& operator++(int);
    inline BiHaar3dDFSScan<F>* clone() const {
      return new BiHaar3dDFSScan<F>(*this);
    }
    inline bool eos() const {return sptr_[0] ? 0 : 1;}
 
  private:
    uint ht_;
    Haar3d000<F>** stk_;
    Haar3d000<F>** sptr_;
  };
 
  // ******************************************************* BiHaar3dBFSScan **
 
  template<class F = concepts::Real>
  class BiHaar3dBFSScan : public Haar3dBFSScan<F> {
  public:
    BiHaar3dBFSScan(Haar3d000<F>* elm, uint ht);
    BiHaar3dBFSScan(const BiHaar3dBFSScan<F>& sc);
    inline ~BiHaar3dBFSScan() {delete[] stk_;}
 
    Haar3d000<F>& operator++(int);
    inline BiHaar3dBFSScan* clone() const {
      return new BiHaar3dBFSScan<F>(*this);
    }
    inline bool eos() const {return sptr_[0] ? 0 : 1;}
    void skip(uint lvl);
 
  private:
    uint ht_;
    Haar3d000<F>** stk_;
    Haar3d000<F>** sptr_;
  };
 
  // ************************************************************** BiHaar3d **
 
  template<class F = concepts::Real>
  class BiHaar3d : public Haar3d<F> {
  public:
    BiHaar3d(BiTree<BiClNode00<F> >& tree);
    inline ~BiHaar3d() {destructor_(elm_);}
 
    inline uint dim() const {return dim_;}
    inline uint nelm() const {return nelm_;}
    inline uint nlvl() const {return nlvl_;}
    inline BiHaar3dDFSScan<F>* dfsscan() const;
    inline BiHaar3dBFSScan<F>* bfsscan() const;
    inline BiHaar3dBFSScan<F>* scan() const;
 
  protected:
    std::ostream& info(std::ostream& os) const;
 
  private:
    Haar3d000<F>* constructor_(BiClNode00<F>* nd, concepts::Real* m,
             typename Haar3dXXX<F, 2>::Key& key);
 
    void destructor_(Haar3d000<F>* elm);
 
    uint dim_;
    uint nelm_;
    uint nlvl_;
    Haar3d000<F>* elm_;
  };
 
  template<class F>
  inline BiHaar3dDFSScan<F>* BiHaar3d<F>::dfsscan() const {
    return new BiHaar3dDFSScan<F>(elm_, nlvl_);
  }
 
  template<class F>
  inline BiHaar3dBFSScan<F>* BiHaar3d<F>::bfsscan() const {
    return new BiHaar3dBFSScan<F>(elm_, nlvl_);
  }
 
  template<class F>
  inline BiHaar3dBFSScan<F>* BiHaar3d<F>::scan() const {
    return new BiHaar3dBFSScan<F>(elm_, nlvl_);
  }
 
  template<class F>
  std::ostream& BiHaar3d<F>::info(std::ostream& os) const {
    os << "aglowav::" << concepts::typeOf(*this)<< "(dim = " << dim_ << ", nlevel = " << nlvl_;
    return os << ", nElement = " << nelm_ << ')';
  }
 
} // namespace aglowav
 
#endif // aglowavSpace_hh