toolbox/scannerConnectors.hh

Go to the documentation of this file.

/* Scanners and Containers
 */

#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_;
  };

} // namespace concepts

#endif //  scannerConnectors_hh