scannerConnectors.hh

Go to the documentation of this file.

 
#ifndef scannerConnectors_hh
#define scannerConnectors_hh
 
#include <vector>
#include "basics/typedefs.hh"
#include "basics/outputOperator.hh"
#include "basics/debug.hh"
#include "basics/exceptions.hh"
#include "toolbox/array.hh"
 
// debugging Joiner
#define JoinerConstr_D 0
#define JoinerDestr_D 0
 
namespace concepts {
 
  // ****************************************************************** Scan **
 
  template <class T> 
  class Scan {
  public:
    virtual ~Scan() {};
 
    operator int() { return !eos(); }
 
    virtual bool eos() const = 0;
    virtual T& operator++(int) = 0;
    virtual Scan* clone() const = 0;
  };
 
  // ************************************************************* Joiner **
 
  template<class T, unsigned nlnk>
  class Joiner;
 
  template<class T, unsigned nlnk>
  std::ostream& operator<<(std::ostream& os,
         const Joiner<T, nlnk>& j);
 
  template<class T, unsigned nlnk>
  class Joiner {
    friend std::ostream& operator<< <>(std::ostream& os,
               const Joiner<T, nlnk>& j);
  public:
    inline Joiner(const T& val, Joiner* lnk = 0);
 
    inline ~Joiner() {}
 
    static void destructor(Joiner<T, nlnk>*& j, bool values = true);
 
    inline Joiner*& operator[](uint i) {
      conceptsAssert(i < nlnk, Assertion());
      return lnk_[i]; 
    }
 
    inline T& value() { return val_; }
 
  private:
    Joiner<T, nlnk>* lnk_[nlnk];
 
    T val_;
 
    Joiner(const Joiner&);
    void operator =(const Joiner&);
 
    static void destructor_(Joiner<T, nlnk>* j, bool values = true);
  };
  
  template <class T, unsigned nlnk>
  Joiner<T, nlnk>::Joiner(const T& val, Joiner<T, nlnk>* lnk) :
    val_(val) {
    DEBUGL(JoinerConstr_D, "start.");
    for(uint i = 0; i < nlnk - 1; ++i)
      lnk_[i] = 0;
    lnk_[nlnk - 1] = lnk;
    DEBUGL(JoinerConstr_D, "done.");
  }
 
  template <class T, unsigned nlnk>
  void Joiner<T, nlnk>::destructor(Joiner<T, nlnk>*& j, bool values) {
    DEBUGL(JoinerDestr_D, "start.");
    if (nlnk > 1) {
      if (j) {destructor_(j);  j = 0;}
    }
    else {
      while (j) {
        Joiner<T, 1>* foo = j;
        j = j->lnk_[0];
        if (values) delete foo->val_;
        delete foo;
      }
    }
    DEBUGL(JoinerDestr_D, "done.");    
  }
 
  template <class T, unsigned nlnk>
  void Joiner<T, nlnk>::destructor_(Joiner<T, nlnk>* j, bool values) {
    for(uint i = 0; i < nlnk; i++) {
      if (j->lnk_[i]) destructor_(j->lnk_[i]);
    }
    if (values) delete j->val_;
    delete j;
  }
 
  template<class T, unsigned nlnk>
  std::ostream& operator<<(std::ostream& os, const Joiner<T, nlnk>& j) {
    os << "J(" << j.val_ << " -> [" << std::flush;
    for(uint i = 0; i < nlnk-1; ++i)
      if (j.lnk_[i])
  os << *j.lnk_[i] << ", " << std::flush;
    if (j.lnk_[nlnk-1])
      os << *j.lnk_[nlnk-1] << std::flush;
    return os << "])" << std::flush;
  }
 
  // ************************************************************* PListScan **
 
  template <class T>
  class PListScan : public Scan<T> {
    Joiner<T*, 1>* head_;
 
    Joiner<T*, 1>* current_;
 
    bool eos_;
  public:
    PListScan(Joiner<T*, 1>& cnr) :
      head_(&cnr), current_(&cnr), eos_(head_ ? false : true) {}
 
    bool eos() const { return eos_; }
 
    PListScan<T>* clone() const { return new PListScan<T>(*this); }
 
    T& operator++(int);
  };
 
  template <class T> 
  T& PListScan<T>::operator++(int) {
 
    T* tmp = 0;
    if (!eos_) {
      tmp = current_->value();
      current_ = (*current_)[0];
      if ((eos_ = current_ == 0)) current_ = head_;
    }
    return *tmp;
  }
 
  // ************************************************************** ListScan **
 
  template <class T>
  class ListScan : public Scan<T> {
    Joiner<T, 1>* head_;
 
    Joiner<T, 1>* current_;
 
    bool eos_;
  public:
    ListScan(Joiner<T, 1>& cnr) :
      head_(&cnr), current_(&cnr), eos_(head_ ? false : true) {}
 
    bool eos() const { return eos_; }
 
    ListScan<T>* clone() const { return new ListScan<T>(*this); }
 
    T& operator++(int);
  };
 
  template <class T> 
  T& ListScan<T>::operator++(int) {
 
    T& tmp = current_->value();
 
    if (!eos_) {
      current_ = (*current_)[0];
      if ((eos_ = current_ == 0)) current_ = head_;
    }
 
    return tmp;
  }
 
  // ******************************************************** PStlVectorScan **
 
  template<class T>
  class PStlVectorScan : public Scan<T> {
  public:
    inline PStlVectorScan(typename std::vector<T*>& v) 
      : i_(v.begin()), last_(v.end()) {}
    inline PStlVectorScan(typename std::vector<T*>::iterator first,
                          typename std::vector<T*>::const_iterator last) 
      : i_(first), last_(last) {}
    inline PStlVectorScan(const PStlVectorScan<T> &scan) 
      : i_(scan.i_), last_(scan.last_) {}
    inline bool eos() const { return i_ == last_; }
    inline T& operator++(int) { return **i_++; }
    inline PStlVectorScan<T>* clone() const { return new PStlVectorScan(*this); }
  private:
    typename std::vector<T*>::iterator       i_;
    typename std::vector<T*>::const_iterator last_;
  };
 
  // ********************************************************* StlVectorScan **
 
  template <class T, class ItType  = typename std::vector<T*>::const_iterator >
  class StlVectorScan : public Scan<T> {
    typedef std::vector<T*> Vector;
 
    const Vector& vec;
    ItType it;
 
 
  public:
    StlVectorScan(const Vector& vec, ItType it)
      : vec(vec), it(it)
    {}
 
    StlVectorScan(Vector& vec)
      : vec(vec), it(vec.begin())
    {}
 
    bool eos() const { return it == vec.end(); }
 
    StlVectorScan* clone() const { return new StlVectorScan(*this); }
 
    T& operator*() {
      return **it;
    }
 
    T& operator++(int) {
      T* old = *it;
      ++it;
      return *old;
    }
 
    T& operator++() {
      return *(++it);
    }
 
  };
 
  // ************************************************************* ArrayScan **
 
  template<class T>
  class ArrayScan : public Scan<T> {
  public:
    inline ArrayScan(Array<T>& container)
      : idx_(0), container_(container) {}
    inline ArrayScan(const ArrayScan& scan) :
      idx_(scan.idx_), container_(scan.container_) {}
    inline bool eos() const { return idx_ == container_.size(); }
    inline T& operator++(int) { return container_[idx_++]; }
    inline Scan<T>* clone() const { return new ArrayScan(*this); }
  private:
    uint idx_;
    Array<T>& container_;
  };
 
  // *********************************************************** SingletonScan **
 
  template<class T>
  class SingletonScan : public concepts::Scan<T> {
  public:
    SingletonScan(T& singleton) : 
      singleton_(singleton), eos_(false) {}
 
    SingletonScan(const SingletonScan& other) : 
      singleton_(other.singleton_), eos_(other.eos_) {}      
      
    bool eos() const /*override*/ { return eos_; }
 
    T&  operator++ (int) /*override*/ { 
      conceptsAssert(!eos_, concepts::Assertion());
      eos_ = true;
      return singleton_;
    }
 
    SingletonScan* clone () const /*override*/ {
      return new SingletonScan(*this);
    }
    
  private:
    T& singleton_;
    bool eos_;
  };  
  
} // namespace concepts
 
#endif //  scannerConnectors_hh