---

/home/slang/XVision2/src/Pipes/Switcher.h

#ifndef __pipeswitcher_h_
#define __pipeswitcher_h_

#include "PipeModules.h"

template <class T>
class Maybe : Pair<Pipe<bool>,T> {
 public:
  Maybe(const Pipe<bool> &x, T &y) : Pair(x,y) {};
  
  bool has_value() const { return lval; };
  T operator *() { assert(lval); return rval; };
};

typedef Pipe<bool> boolP;

template<class T> 
class Event : Pipe<T> {

  Pipe<T> *behavior;
  bool    (*cond) (const int&);
  typedef bool (*bool_func)(const int&);

 public:

  Event() : Pipe() {}
  Event(Pipe<T> &x, bool (*y)(const int&)) : Pipe(), behavior(&x), cond(y) {}

  bool has_value(const int& val) const { return cond(val); }
  Pipe<T>* get_behavior() { return behavior; }
  bool_func get_cond_func() { return cond; }
  operator Pipe<T>* *() { assert(cond); return behavior; }
};

template<class T>
class PipeUntil : public PipeModule<T> {

  Pipe<T>  *current;
  Event<T> *pred;
  bool been_set;

 protected:

  inline void check(void) { PipeModule<T>::check( pred ); }

 public:

  PipeUntil(): PipeModule(), been_set(false) {}
  PipeUntil(Pipe<T> &x, Event<T>& e) : current(&x), pred(&e), been_set(false) {}
  
  T compute_local_fn(int fc) {
    check();
    T temp = current->get_value(fc);
    if (pred->has_value(fc) && been_set == false) {
      been_set = true;
      current = pred->get_behavior();
    }
    return temp;
  }
  
  void keepup( int fc ) { current->get_value(fc); }
  
  operator Pipe<T> () const 
    { return Pipe<T>(new PipeUntil<T>(*this)); }
  
  Pipe<T> operator () (const Pipe<T>& x) const {
    PipeUntil *p = new PipeUntil<T>();
    p->pred = new Event<T>(x, pred->get_cond_func());
    return Event<T>(p);
  }
};

template <class T>
class PipeSwitch: public PipeModule<T> {
  
  const Pipe<T>  *current;
  const Event<T> *evt;
  
 public:
  
  PipeSwitch(const Pipe<T>& p, Event<T>& e) : current(&p), evt(&e) {};
  
  Pipe<T> &operator () (Pipe<T> &x, Event<T> &y) const {
    PipeSwitch *temp = new PipeSwitch<T>();
    Pipe<T> *tempp = new Pipe<T>(temp);
    temp->current = new Pipe<T>(&x);
    temp->evt = new Pipe<T>(&y);
    return *tempp;
  }
  
  T compute_local_fn(int fc) {
    T temp = current->get_value(fc);
    if (((*evt)->get_value(fc)).has_value()) {
      current = *(evt->get_value(fc));
    }
    return temp;
  }
};

#endif 

---