---

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

#ifndef __pipemodules_h
#define __pipemodules_h

#include <assert.h>
#include <stream.h>

template <class Tout>
class PipeModule {

protected:

  // The value last computed by this module;
  // cached here to avoid recomputation

  Tout value;
  Tout last; //add by Donald

  // This'll be filled in later when we lift things
  // For now, its a placeholder for constant lifting

  virtual Tout compute_local_fn(int) {return value;};

protected:

  // For bookeeping what data has passed through

  int frame_count;

public:

  PipeModule() {frame_count = -1;};
  PipeModule(Tout x) {value = x;};  // For lifting constants

  // This is the generic updating algorithm ...

  virtual void keepup( int fcin ) {}  //add by Donald

  virtual Tout get_value(int fcin) {

    if( fcin < frame_count) { //add by Donald
      return last ;
    }
    if (fcin > frame_count) {
      last = value ;          //add by Donald
      value = compute_local_fn(fcin);
      frame_count = fcin;
      keepup(fcin);           //add by Donald
    }
    return value;
  }

  virtual Tout next_value() {
    return get_value(frame_count+1);
  }

};

// add by Donald
// exception class
class BrokenPipe {};
// end Donald

// Pipes are what the user actually defines
// They are really Handles, but they carry types and so
// act as a cosmetic sugar on Handles; they also allow automatically
// lifting constants.  In practice, Pipes allow us to make
// equations where the same expression appears on both sides of 
// the statement

template <class Tout>
class Pipe  {

protected:
  friend class PipeModule<Tout>;

  // This is the actual node in the graph that does the work

  PipeModule<Tout> *module;

  // If an uninitialized Pipe is used in an expression, we
  // make a list of nodes that use it an  "backpatch" once an assignment
  // is made; this make it possible to use local variables in Pipe equations 
  // without them having disappeared when the graph is executed.

  Pipe<Tout> *backpatch_nodes; 

  // This does the backpatching once a module assignment is known.

  void backpatch(PipeModule<Tout> *m) {
    module = m;
    if (backpatch_nodes) {
      backpatch_nodes->backpatch(m);
    }
    backpatch_nodes = NULL;
  }


public:

  Pipe() : module(NULL), backpatch_nodes(NULL) {};
  Pipe(PipeModule<Tout> *v) : module(v),  backpatch_nodes(NULL) {};

  // This is the way to create a "backpatch" list; only used internally
  // while constructing the graph; unfortunately it's not possible to
  // easily "friend" it to PipeModule, but it's not for public consumption

  Pipe(Pipe<Tout> *v) : module(v->module),  backpatch_nodes(NULL) {
    if (module == NULL) {
      backpatch_nodes = v->backpatch_nodes;
      v->backpatch_nodes = this;
    }
  };

  // This allows the compler to automatically lift constants

  Pipe(const Tout v) : module(new PipeModule<Tout>(v)) {};

  Pipe(const Pipe<Tout> &v) : module(v.module),  backpatch_nodes(NULL) {
    assert(module != NULL);
  };

  // Ideally, I'd like an automatic cast to the stored PipeModule ..
  // this overload is a little confusing

  PipeModule<Tout> *operator ->() const {return module;}

  Pipe<Tout> &operator=(const Pipe<Tout> &xvp) {
    assert(xvp.module != NULL);
    assert(xvp.backpatch_nodes == NULL);
    backpatch(xvp.module);
    return *this;
  }

  // add by Donald
  void run() { try{ for(;;) module->next_value(); } catch(BrokenPipe) {} }
  // end Donald
};

// We now go into "lifting" operators that admit functions to the class.  There
// are four types of "lifts:" pure functions, class member functions, "implicit" functions, 
// and operators. Implicit functions are needed becuse C++ doesn't allow template 
// matching based on output type, so we have to artifically add another argument to the function.
// Worth noting that we allow class member functions that change internal class state; 
// if we wanted to be militant, we would require those functions to be "const" on the
// class, in which case we get the equivalent of closures.

template <class Tout,class Tclass>
class PipeModuleLiftClass0 : PipeModule<Tout> {

protected:

  // The value last computed by this module;
  // cached here to avoid recomputation

  typedef Tout (Tclass::*LiftC0Type)(void); //modified by Donald

  Tclass state;
  LiftC0Type proc;

  virtual Tout compute_local_fn(int) {return (state.*proc)();};

public:

  PipeModuleLiftClass0(const Tclass &xin,LiftC0Type proc_in) : 
    PipeModule(), state(xin), proc(proc_in) {}

  Pipe<Tout> &operator () () const
    {
      return *(new Pipe<Tout>(new PipeModuleLiftClass0(state,proc)));
    }
};


template <class Tout>
class PipeModuleLift0: public PipeModule<Tout> {

  typedef Tout (*Lift0Type)();
  Lift0Type fn;

public:

  PipeModuleLift0(Lift0Type fnin): PipeModule<Tout>(), fn(fnin) {};

  Pipe<Tout> &operator () () const
    {
      return *(new Pipe<Tout>(new PipeModuleLift0(fn)));
    }

  Tout compute_local_fn(int fc) {return (*fn)();};
};

template <class Tout, class Tin>
class PipeModuleLift1: public PipeModule<Tout> {

  typedef Tout (*Lift1Type)(const Tin&);   
  Lift1Type fn;
  const Pipe<Tin> *pred;

public:

  PipeModuleLift1(Lift1Type fnin): fn(fnin) {};

  Pipe<Tout> &operator () (Pipe<Tin> &x) const
    {
      PipeModuleLift1 *temp = new PipeModuleLift1<Tout, Tin>(fn);
      Pipe<Tout> *tempp = new Pipe<Tout>(temp);
      temp->pred = new Pipe<Tin>(&x);
      return *tempp;
    }

  Tout compute_local_fn(int fc) 
    {
      return fn((*pred)->get_value(fc));
    }

  void keepup( int fc ) { (*pred)->get_value(fc); }  // add by Donald
};

template <class Tout, class Tin, class Tclass>
class PipeModuleLiftClass1: public PipeModule<Tout> {

  typedef Tout (Tclass::*Lift1Type)(const Tin&);   
  Tclass state;
  Lift1Type fn;
  Pipe<Tin> *pred;

public:

  PipeModuleLiftClass1(Lift1Type fnin, const Tclass &state_in): fn(fnin), state(state_in) {};

  Pipe<Tout> &operator () (Pipe<Tin> &x) const
    {
      PipeModuleLiftClass1 *temp = new PipeModuleLiftClass1<Tout, Tin, Tclass>(fn,state);
      Pipe<Tout> *tempp = new Pipe<Tout>(temp);
      temp->pred = new Pipe<Tin>(&x);
      return *tempp;
    }

  Tout compute_local_fn(int fc) 
    {
      return (state.*fn)((*pred)->get_value(fc));
    }

  void keepup( int fc ) { (*pred)->get_value(fc); }  // add by Donald
};
template <class Tout, class Tin1>
class PipeModuleLiftImplicit1: public PipeModule<Tout> {
  
  Tout x;
  Tout (*fn)(const Tin1&, Tout&);   
  const Pipe<Tin1> *pred;

public:

  PipeModuleLiftImplicit1(Tout (*fnin)(const Tin1&, Tout&)): fn(fnin) {};

  Pipe<Tout> &operator () (Pipe<Tin1> &x) const
    {
      PipeModuleLiftImplicit1<Tout,Tin1> *temp = new PipeModuleLiftImplicit1<Tout, Tin1>(fn);
      Pipe<Tout> *tempp = new Pipe<Tout>(temp);
      temp->pred = new Pipe<Tin1>(&x);
      return *tempp;
    }

  Tout compute_local_fn(int fc) 
    {
      return fn((*pred)->get_value(fc),x);
    }

  void keepup( int fc ) { (*pred)->get_value(fc); }  // add by Donald
};


template <class Tout, class Tin1, class Tin2>
class PipeModuleLift2: public PipeModule<Tout> {
  
  Tout (*fn)(const Tin1&, const Tin2&);   
  const Pipe<Tin1> *pred1;
  const Pipe<Tin2> *pred2;

public:

  PipeModuleLift2(Tout (*fnin)(const Tin1&, const Tin2&)): fn(fnin) {};

  Pipe<Tout> &operator () (Pipe<Tin1> &x, Pipe<Tin2> &y)  const
    {
      PipeModuleLift2 *temp = new PipeModuleLift2<Tout, Tin1, Tin2>(fn);
      Pipe<Tout> *tempp = new Pipe<Tout>(temp);
      temp->pred1 = new Pipe<Tin1>(&x);
      temp->pred2 = new Pipe<Tin2>(&y);
      return *tempp;
    }

  Tout compute_local_fn(int fc) 
    {
      return fn((*pred1)->get_value(fc),
          (*pred2)->get_value(fc));
    }

  void keepup( int fc ) { (*pred1)->get_value(fc); 
                          (*pred2)->get_value(fc); }  // add by Donald
};


template <class Tout, class Tin1, class Tin2, class Tin3>
class PipeModuleLift3: public PipeModule<Tout> {
  
  Tout (*fn)(const Tin1&, const Tin2&, const Tin3&);   
  const Pipe<Tin1> *pred1;
  const Pipe<Tin2> *pred2;
  const Pipe<Tin3> *pred3;

public:

  PipeModuleLift3(Tout (*fnin)(const Tin1&, const Tin2&, const Tin3&)): fn(fnin) {};

  Pipe<Tout> &operator () (Pipe<Tin1> &x, Pipe<Tin2> &y, Pipe<Tin3> &z)  const
    {
      PipeModuleLift3 *temp = new PipeModuleLift3<Tout, Tin1, Tin2, Tin3>(fn);
      Pipe<Tout> *tempp = new Pipe<Tout>(temp);
      temp->pred1 = new Pipe<Tin1>(&x);
      temp->pred2 = new Pipe<Tin2>(&y);
      temp->pred3 = new Pipe<Tin3>(&z);
      return *tempp;
    }

  Tout compute_local_fn(int fc) 
    {
      return fn((*pred1)->get_value(fc),
          (*pred2)->get_value(fc),
          (*pred3)->get_value(fc));
    }

  void keepup( int fc ) { (*pred1)->get_value(fc); 
                          (*pred2)->get_value(fc);
                          (*pred3)->get_value(fc); }  // add by Donald
};

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

  int have_value;
  int beencalled;
  T val;
  const Pipe<T> *pred;

  void set_value(T v) {val = v; have_value = 1;}

public:

  PipeDelay() {beencalled = 0;have_value=0;};

  Pipe<T> &operator () (Pipe<T> &x,T firstval)  const
    {
      PipeDelay<T> *temp = new PipeDelay<T>;
      Pipe <T> *tempp = new Pipe<T>(temp);
      temp->set_value(firstval);
      temp->pred = new Pipe<T> (&x);
      return *tempp;
    }

  // This allow a "partial evaluation" of delay

  Pipe<T> &operator () (Pipe<T> &x) const
    {
      if (have_value) {
     return (*this)(x,val);
      }
      else {
     cerr << "Attempt to call uninitialized PipeDelay" << endl;
     exit(1);
      }
    }

  PipeDelay<T> &operator () (T firstval)  const
    {
      PipeDelay<T> *temp = new PipeDelay<T>;
      temp->set_value(firstval);
      return *temp;
    }

  T compute_local_fn(int fc) 
    {
      if (!beencalled) {
     beencalled = 1;
     return val;
      }
      else
        return((*pred)->get_value(fc-1));
    }

  void keepup( int fc ) { (*pred)->get_value(fc); }  // add by Donald
};


// IO Side effects

template <class T>
class PipeModuleLiftIO: public PipeModule<T> {
  
  int (*fn)(const T&);   
  Pipe<T> *pred;

public:

  PipeModuleLiftIO(int (*fnin)(const T&)): fn(fnin) {};

  Pipe<T> &operator () (const Pipe<T> &x)
    {
      PipeModuleLiftIO *temp = new PipeModuleLiftIO<T>(fn);
      Pipe<T> *tempp = new Pipe<T>(temp);
      temp->pred = new Pipe<T>(&x);
      return *tempp;
    }

  T compute_local_fn(int fc) 
    {
     if (fn((*pred)->get_value(fc)))
       return get_value(fc);
     else {
       cerr << "Error in IO" << endl;
       exit(1);
     }
    }

  void keepup( int fc ) { (*pred)->get_value(fc); }  // add by Donald
};

template <class T>
class PipeModulePrint: public PipeModule<T> {
  
  Pipe<T> *pred;

public:

  Pipe<T> &operator () (const Pipe<T> &x)
    {
      PipeModulePrint *temp = new PipeModulePrint<T>();
      Pipe<T> *tempp = new Pipe<T>(temp);
      temp->pred = new Pipe<T>(&x);
      return *tempp;
    }

  T compute_local_fn(int fc) 
    {
      cout  << (*pred)->get_value(fc) << endl;
      return (*pred)->get_value(fc);
    }

  void keepup( int fc ) { (*pred)->get_value(fc); }  // add by Donald
};

// begin Donald

#define LiftBinOp(OP,NM) \
template <class T1, class T2>\
class PipeModuleLiftBin##NM: public PipeModule<T1> {\
\
const Pipe<T1> *pred1;\
const Pipe<T2> *pred2;\
public:\
\
  PipeModuleLiftBin##NM(Pipe<T1> &x, Pipe<T2> &y): PipeModule<T1>() \
  {\
      pred1= new Pipe<T1>(&x);\
      pred2= new Pipe<T2>(&y);\
  };\
\
  T1 compute_local_fn(int fc) {\
      return ((*pred1)->get_value(fc) OP\
          (*pred2)->get_value(fc));\
  }\
\
  void keepup( int fc ) { (*pred1)->get_value(fc); \
                          (*pred2)->get_value(fc); }\
};\
\
template <class T1, class T2>\
Pipe<T1> &operator##OP(Pipe<T1> &x, Pipe<T2> &y)\
{\
  return *(new Pipe<T1>(new PipeModuleLiftBin##NM<T1,T2>(x,y)));\
}\
template <class T1, class T2>\
Pipe<T1> &operator##OP(Pipe<T1> &x, const T2 y)\
{\
  return *(new Pipe<T1>(new PipeModuleLiftBin##NM<T1,T2>(x,y)));\
}\
template <class T1, class T2>\
Pipe<T1> &operator##OP(const T1 x, Pipe<T2> &y)\
{\
  return *(new Pipe<T1>(new PipeModuleLiftBin##NM<T1,T2>(x,y)));\
}\
// end Donald

template <class T1, class T>
Pipe<T1> &operator << (const PipeModuleLift1<T1,T> &x, Pipe<T> &y)
{
  return x(y);
}  

template <class T1, class T>
Pipe<T1> &operator << (const PipeModuleLiftImplicit1<T1,T> &x, Pipe<T> &y)
{
  return x(y);
}  

template <class T1, class T, class Tclass>
Pipe<T1> &operator << (const PipeModuleLiftClass1<T1,T,Tclass> &x, Pipe<T> &y)
{
  return x(y);
}  

template <class T>
Pipe<T> &operator << (const PipeDelay<T> &x, Pipe<T> &y)
{
  return x(y);
}  

LiftBinOp(+,Plus)
LiftBinOp(-,Minus)
     //add by Donald
LiftBinOp(*,Multiply)
LiftBinOp(/,Divide)
LiftBinOp(<<,LeftShift)
     //end Donald

template <class T1, class T2>
class Pair {
public:
  T1 lval;
  T2 rval;

  Pair() {}; // needed to be able to declare an empty variable for Pipes
  Pair(const T1 &x, const T2 &y) :  lval(x), rval(y) {};
};

template <class T1, class T2>
Pair<T1,T2> Pairup(const T1 &x, const T2 &y)
{
  return Pair<T1,T2>(x,y);
}

template <class T1, class T2>
ostream &operator << (ostream &outs,Pair<T1,T2> v)
{
  outs << "(" << v.lval << ", " << v.rval << ")";
}
    
template <class T1, class T2>
Pipe<Pair<T1,T2> > &operator&&(Pipe<T1> &x, Pipe<T2> &y)
{
  Pair<T1,T2> (*Pairupf)(const T1 &,const T2 &) = &Pairup;
  PipeModuleLift2<Pair<T1,T2>,T1,T2 > temp(Pairupf);

  return temp(x,y);
}


#endif

---