---

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

# ifndef _PIPEMODULES_H_
# define _PIPEMODULES_H_

# include <XVException.h>
# include <XVFunctoid.h>
# include "Dependency.h"

// Here defines pipe exception classes. Instead of to abort when a run time 
// error encountered, to throw out an exception and give user a chance to
// catch them is a more elegant way. The nature of the expection can be 
// determined by its type.
// Note: In release version the exception object should contain more 
// information besides type.

// root of all pipe exceptions
class PipeException : public XVException { protected:
  PipeException() : XVException("Pipe Exception") {} 
  PipeException( char * err ) : XVException(err) {} };  

// source exhausted
class BrokenPipe : public PipeException { public:
  BrokenPipe() : PipeException("Broken Pipe") {} 
  BrokenPipe( char * err ) : PipeException(err) {} };  

// uninitialized pipe
class UninitPipe : public PipeException { public:
  UninitPipe() : PipeException("Uninitialized Pipe") {} 
  UninitPipe( char * err ) : PipeException(err) {} };  

// redefine pipe behavior
class RedefPipe : public PipeException { public:
  RedefPipe() : PipeException("Redefined Pipe") {} 
  RedefPipe( char * err ) : PipeException(err) {} };  

// PipeModule is the real calculation unit, and also serves as 
// the root class for hierarchy the pipe classes.
// If an garbage collector is going to be implemented, this is where
// operator new and delete should be overridden.

template<class T> class Pipe;

template<class T>
class PipeModule : protected DependencyUnit {
  struct Update {
    int fc ;
    T * addr ;
    Update * next ;
    Update( int fc, T * addr, Update * next=0 ) :
      fc(fc), addr(addr), next(next) {}
    ~Update() { delete next ; }
  } * head ;

 protected:
  void addUpdate( int fc, T * addr ) { head = new Update( fc, addr, head ); }
  void update( int fc, const T& data ) {
    Update ** p ;
    int k = 0 ;
    for( p = &head ; *p ; ) {
      if( (*p)->fc == fc ) {
     *((*p)->addr) = data ;
      }
      if( fc - (*p)->fc < 0 ) {  // leave it alone
     p = &((*p)->next);
      }else {                    // delete the node
     Update * temp = *p ;
     *p = temp->next ;
     temp->next = 0 ;
     delete temp ;
      }
    }
  }

 protected:          // The real meat of PipeModule
  int frame_count ;

  T value ;    // value of current frame count

 protected:
# ifndef NDEBUG
  inline void check( bool statement ) const 
    { if( !statement ) throw UninitPipe(); }
# else
  inline void check( bool ) const {}
# endif

 protected:          // Module dependency and duplication functions

  void setDependency(void) {}
  PipeModule<T> * duplicate(void) const { return new PipeModule<T>(*this); }

 public:
  typedef T ReturnType ;   // to retrieve the return type from a given template
  typedef Pipe<T> ResultType ; // the type returned by operator ()

  PipeModule() : head(0), frame_count(-1) { setDependency(); }
  PipeModule( const PipeModule<T>& p ) : DependencyUnit(p),
    head(0), frame_count(p.frame_count), value(p.value) // last(p.last) 
    { setDependency(); }
  PipeModule( const T& x ) : 
    head(0), frame_count(-1), value(x) { setDependency(); }

  virtual T current_value(void) const { return value ; }

  virtual T compute_local_fn(int) { return value; }  // for constant lift

  virtual T get_value( int fcin ) {
    if( fcin != frame_count ) {            // try to pull out the new value
      value = compute_local_fn( fcin );
      frame_count = fcin ;
      update( frame_count, value );
    }
    return value ;
  }
  virtual void get_value( int fcin, T * ptr )  {    // late get
    if( fcin != frame_count ) {
      addUpdate( fcin, ptr );
    }else {
      *ptr = value ;
    }
  }
  
  virtual T next_value() {
    return get_value( frame_count+1 );
  }
};

// Pipe is a handle to the real PipeModule, plus allowing assignment 
// between Pipes in order to construct the graph.

template <class T>
class Pipe : public PipeModule<T> {
 protected:
  PipeModule<T> ** module ;   // *module == 0 indicate uninitialized pipe

 protected:
  void setDependency(void) { addDependency((DependencyUnit**)module); }
  Pipe<T> * duplicate(void) const { return new Pipe<T>(*module); }

  //inline void check(void) const { PipeModule<T>::check( *module ); }
  inline void check(void) const { PipeModule<T>::check( *module ); }

 public:
  Pipe() : module(new (PipeModule<T> *)(0)) { setDependency(); }
  // copy constructor
  Pipe( const Pipe& p ) : PipeModule<T>(p), module(p.module) 
    { setDependency(); }

  // for constant lifting
  Pipe( const T& x ) : module(new (PipeModule<T> *)(new PipeModule<T>(x))) 
    { setDependency(); }

  // for internal use
  Pipe( PipeModule<T> *v ) : module(new (PipeModule<T> *)(v)) 
    { setDependency(); } 

  Pipe<T>& operator = ( const Pipe<T>& p ) 
    { 
      if( &p != this ) {   // nothing happens for self assignment
        if( *module ) throw RedefPipe(); 
        //*module = *(p.module); 
        *module = new Pipe<T>(p) ;
      }
      return *this ; 
    }

  T current_value(void) const { check(); return (*module)->current_value() ; }
  T get_value( int fcin ) { check(); return (*module)->get_value(fcin); }
  void get_value( int fcin, T * ptr ) 
    { check(); return (*module)->get_value(fcin, ptr); }
  T next_value() { check(); return (*module)->next_value(); }
  PipeModule<T>* operator ->() { check(); return *module ; }

  void run() 
    { check(); try{ for(;;) (*module)->next_value(); } catch(BrokenPipe) {} }
  void run( unsigned int n ) 
    {
      check();
      try{
     for( int i = 0 ; i < n ; i ++ ) {
       (*module)->next_value();
     }
      }catch(BrokenPipe) {}
    }

  template<class Tout, class Tin1> friend class PipeFun1 ;
  template<class Tout, class Tin1, class Tin2> friend class PipeFun2 ;
};

// 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.

// Donald: Obviously STL functional library can be used to avoid repetitive 
// code when lifting various form of functions, however, it's still not 
// enough for the task, so instead of extend STL I'm writing a functional 
// class hierarchy of its own, which is in XVFunctoid.h. It's still under
// construction, so we have to use this old and lengthy code for a while.

// These are "generic" definitions of lifted functions useful for abstracting
// intermediate pipeline expressions --- essentially making the function
// operator "generic."  This is also where we could define partial
// evaluation types generically if we wanted to ...

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

  PipeLift0() : PipeModule<Tout>() {};
  PipeLift0( const PipeLift0<Tout>& p ) : PipeModule<Tout>(p) {};

  virtual Pipe<Tout> operator()(void) const = 0;
};

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

  PipeLift1() : PipeModule<Tout>() {};
  PipeLift1( const PipeLift1<Tout,Tin>& p ) : PipeModule<Tout>(p) {};

  virtual Pipe<Tout> operator()(const Pipe<Tin>&) const = 0;
};

template <class Tout,class Tin1, class Tin2>
class PipeLift2 : public PipeModule<Tout>
{
public:

  PipeLift2() : PipeModule<Tout>() {};
  PipeLift2( const PipeLift2<Tout,Tin1,Tin2>& p ) : PipeModule<Tout>(p) {};

  //virtual Pipe<Tout> operator()(const Pipe<Tin1>&,const Pipe<Tin2>&) const = 0;
};


template <class Tout, class Tin1, class Tin2, class Tin3>
class PipeLift3 : public PipeModule<Tout>
{
public:

  PipeLift3() : PipeModule<Tout>() {};
  PipeLift3( const PipeLift3<Tout,Tin1,Tin2,Tin3>& p ) : PipeModule<Tout>(p) {};

  virtual Pipe<Tout> operator()(const Pipe<Tin1>&,const Pipe<Tin2>&, const Pipe<Tin3> &) const = 0;
};


// 1. Pure functions, in form of Tout func( Tin1, Tin2, ... )

template<class Tout>
class PipeModuleLift0 : public PipeLift0<Tout> {
  typedef PipeModuleLift0<Tout> ThisType ;
  typedef PipeLift0<Tout> BaseType ;
 protected:
  typedef Tout (*Lift0Type)(void);
  Lift0Type fn ;

 protected:

  void setDependency(void) {}
  ThisType * duplicate(void) const { return new ThisType(*this);}

 protected:

  inline void check(void) { PipeModule<Tout>::check( fn ); }

 public:

  PipeModuleLift0( Lift0Type fnin ) : fn(fnin) { setDependency(); }
  PipeModuleLift0( const ThisType& p ) : BaseType(p), 
    fn(p.fn) { setDependency(); }

  operator Pipe<Tout> () const { return Pipe<Tout>(dupilcate()); }

  Pipe<Tout> operator ()(void) const { return Pipe<Tout>(duplicate()); }

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

// Lift functions from element to pipe level
// Use a PipeModule to represent that function
// Note that liftP is overloaded for all applied lift classes.

template<class Tout> 
inline Pipe<Tout> liftP( Tout (*fn)(void) ) {
  return Pipe<Tout>(new PipeModuleLift0<Tout>(fn));
}

template <class Tout, class Tin1, class Fn>
class PipeModuleLift1 : public PipeLift1<Tout,Tin1> {
  typedef PipeModuleLift1<Tout,Tin1,Fn> ThisType ;
  typedef PipeLift1<Tout,Tin1> BaseType ;
 protected:
  Fn fn ;
  Pipe<Tin1> *pred1 ;

 protected:

  void setDependency(void) { addDependency((DependencyUnit**)&pred1); }
  ThisType * duplicate(void) const { return new ThisType(*this); }

  inline void check(void) 
    { PipeModule<Tout>::check( (bool)fn && pred1 ); }

 public:

  PipeModuleLift1( Fn fnin ) : fn(fnin), pred1(0) { setDependency(); } 
  PipeModuleLift1( const ThisType& p ) : 
    BaseType(p), fn(p.fn), pred1(p.pred1) { setDependency(); } 

  Pipe<Tout> operator ()( const Pipe<Tin1>& x ) const 
    { 
      ThisType *p = duplicate();
      p->pred1 = new Pipe<Tin1>(x) ;
      return Pipe<Tout>(p) ; 
    }

  Tout compute_local_fn( int fc ) 
    { check(); return fn(pred1->get_value(fc)); }
};

template<class Tout, class Tin1>
class PipeModuleLift1Types {
 public:
  typedef PipeModuleLift1<Tout,Tin1,Tout (*)(Tin1)> Val;
  typedef PipeModuleLift1<Tout,Tin1,Tout (*)(const Tin1&)> Ref;
};

template<class Tout, class Tin1> 
inline PipeModuleLift1<Tout, Tin1, Tout (*)(Tin1)> 
liftP( Tout (*fn)(Tin1) ) {
  return PipeModuleLift1<Tout,Tin1,Tout (*)(Tin1)>(fn);
}
template<class Tout, class Tin1> 
inline PipeModuleLift1<Tout, Tin1, Tout (*)(const Tin1&)> 
liftP( Tout (*fn)(const Tin1&) ) {
  return PipeModuleLift1<Tout,Tin1,Tout (*)(const Tin1&)>(fn);
}


template <class Tout, class Tin1, class Tin2, class Fn>
class PipeModuleLift2 : public PipeLift2<Tout,Tin1,Tin2> {
  typedef PipeModuleLift2<Tout,Tin1,Tin2,Fn> ThisType ;
  typedef PipeLift2<Tout,Tin1,Tin2> BaseType ;
 protected:
  Fn fn ;
  Pipe<Tin1> *pred1 ;
  Pipe<Tin2> *pred2 ;

 protected:

  void setDependency(void) 
    { 
      addDependency((DependencyUnit**)&pred1); 
      addDependency((DependencyUnit**)&pred2); 
    }
  ThisType * duplicate(void) const { return new ThisType(*this); }

  inline void check(void) 
    { PipeModule<Tout>::check( (bool)fn&&pred1&&pred2 ); }

 public:

  PipeModuleLift2( Fn fnin ) : fn(fnin), pred1(0), pred2(0) 
    { setDependency(); } 
  PipeModuleLift2( const ThisType& p ) : BaseType(p), fn(p.fn), 
    pred1(p.pred1), pred2(p.pred2) { setDependency(); } 

  virtual Pipe<Tout> operator ()( const Pipe<Tin1>& x1, const Pipe<Tin2>& x2 ) const
    { 
      ThisType *p = duplicate();
      p->pred1 = new Pipe<Tin1>(x1); 
      p->pred2 = new Pipe<Tin2>(x2); 
      return Pipe<Tout>(p) ; 
    }

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

template<class Tout, class Tin1, class Tin2>
class PipeModuleLift2Types {
 public:
  typedef PipeModuleLift2<Tout,Tin1,Tin2,Tout (*)(Tin1,Tin2)> Val;
  typedef PipeModuleLift2<Tout,Tin1,Tin2,
    Tout (*)(const Tin1&,const Tin2&)> Ref;
};

template<class Tout, class Tin1, class Tin2> 
inline PipeModuleLift2<Tout, Tin1, Tin2, Tout (*)(Tin1,Tin2)> 
liftP( Tout (*fn)(Tin1,Tin2) ) {
  return PipeModuleLift2<Tout,Tin1,Tin2,Tout (*)(Tin1,Tin2)>(fn);
}
template<class Tout, class Tin1, class Tin2> 
inline PipeModuleLift2<Tout, Tin1, Tin2, Tout (*)(const Tin1&,Tin2)> 
liftP( Tout (*fn)(const Tin1&,Tin2) ) {
  return PipeModuleLift2<Tout,Tin1,Tin2,Tout (*)(const Tin1&,Tin2)>(fn);
}
template<class Tout, class Tin1, class Tin2> 
inline PipeModuleLift2<Tout, Tin1, Tin2, Tout (*)(Tin1,const Tin2&)> 
liftP( Tout (*fn)(Tin1,const Tin2&) ) {
  return PipeModuleLift2<Tout,Tin1,Tin2,Tout (*)(Tin1,const Tin2&)>(fn);
}
template<class Tout, class Tin1, class Tin2> 
inline PipeModuleLift2<Tout, Tin1, Tin2, Tout (*)(const Tin1&,const Tin2&)> 
liftP( Tout (*fn)(const Tin1&,const Tin2&) ) {
  return PipeModuleLift2<Tout,Tin1,Tin2,Tout (*)(const Tin1&,const Tin2&)>(fn);
}

template <class Tout, class Tin1, class Tin2, class Tin3, class Fn>
class PipeModuleLift3 : public PipeLift3<Tout,Tin1,Tin2,Tin3> {
  typedef PipeModuleLift3<Tout,Tin1,Tin2,Tin3,Fn> ThisType ;
  typedef PipeLift3<Tout,Tin1,Tin2,Tin3> BaseType ;
 protected:
  Fn fn ;
  Pipe<Tin1> *pred1 ;
  Pipe<Tin2> *pred2 ;
  Pipe<Tin3> *pred3 ;

 protected:

  void setDependency(void) 
    { 
      addDependency((DependencyUnit**)&pred1); 
      addDependency((DependencyUnit**)&pred2); 
      addDependency((DependencyUnit**)&pred3); 
    }
  ThisType * duplicate(void) const { return new ThisType(*this); }

  inline void check(void) 
    { PipeModule<Tout>::check( (bool)fn && pred1 && pred2 && pred3 ); }

 public:

  PipeModuleLift3( Fn fnin ) : fn(fnin), pred1(0), pred2(0), pred3(0) 
    { setDependency(); } 
  PipeModuleLift3( const ThisType& p ) : BaseType(p), fn(p.fn), 
    pred1(p.pred1), pred2(p.pred2), pred3(p.pred3) { setDependency(); }
 
  Pipe<Tout> operator ()( const Pipe<Tin1>& x1, const Pipe<Tin2>& x2,
                          const Pipe<Tin3>& x3 ) const
    { 
      ThisType *p = duplicate();
      p->pred1 = new Pipe<Tin1>(x1); 
      p->pred2 = new Pipe<Tin2>(x2); 
      p->pred3 = new Pipe<Tin3>(x3);
      return Pipe<Tout>(p) ; 
    }

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

template<class Tout, class Tin1, class Tin2, class Tin3>
class PipeModuleLift3Types {
 public:
  typedef PipeModuleLift3<Tout,Tin1,Tin2,Tin3,
    Tout (*)(Tin1,Tin2,Tin3)> Val;
  typedef PipeModuleLift3<Tout,Tin1,Tin2,Tin3,
    Tout (*)(const Tin1&,const Tin2&,const Tin3&)> Ref;
};

template<class Tout, class Tin1, class Tin2, class Tin3> 
inline PipeModuleLift3<Tout, Tin1, Tin2, Tin3, 
  Tout (*)(Tin1,Tin2,Tin3)> 
liftP( Tout (*fn)(Tin1,Tin2,Tin3) ) {
  return PipeModuleLift3<Tout,Tin1,Tin2,Tin3,
    Tout (*)(Tin1,Tin2,Tin3)>(fn);
}
template<class Tout, class Tin1, class Tin2, class Tin3> 
inline PipeModuleLift3<Tout, Tin1, Tin2, Tin3, 
  Tout (*)(Tin1,Tin2,const Tin3&)> 
liftP( Tout (*fn)(Tin1,Tin2,const Tin3&) ) {
  return PipeModuleLift3<Tout,Tin1,Tin2,Tin3,
    Tout (*)(Tin1,Tin2,const Tin3&)>(fn);
}
template<class Tout, class Tin1, class Tin2, class Tin3> 
inline PipeModuleLift3<Tout, Tin1, Tin2, Tin3, 
  Tout (*)(Tin1,const Tin2&,Tin3)> 
liftP( Tout (*fn)(Tin1,const Tin2&,Tin3) ) {
  return PipeModuleLift3<Tout,Tin1,Tin2,Tin3,
    Tout (*)(Tin1,const Tin2&,Tin3)>(fn);
}
template<class Tout, class Tin1, class Tin2, class Tin3> 
inline PipeModuleLift3<Tout, Tin1, Tin2, Tin3, 
  Tout (*)(Tin1,const Tin2&,const Tin3&)> 
liftP( Tout (*fn)(Tin1,const Tin2&,const Tin3&) ) {
  return PipeModuleLift3<Tout,Tin1,Tin2,Tin3,
    Tout (*)(Tin1,const Tin2&,const Tin3&)>(fn);
}
template<class Tout, class Tin1, class Tin2, class Tin3> 
inline PipeModuleLift3<Tout, Tin1, Tin2, Tin3, 
  Tout (*)(const Tin1&,Tin2,Tin3)> 
liftP( Tout (*fn)(const Tin1&,Tin2,Tin3) ) {
  return PipeModuleLift3<Tout,Tin1,Tin2,Tin3,
    Tout (*)(const Tin1&,Tin2,Tin3)>(fn);
}
template<class Tout, class Tin1, class Tin2, class Tin3> 
inline PipeModuleLift3<Tout, Tin1, Tin2, Tin3, 
  Tout (*)(const Tin1&,Tin2,const Tin3&)> 
liftP( Tout (*fn)(const Tin1&,Tin2,const Tin3&) ) {
  return PipeModuleLift3<Tout,Tin1,Tin2,Tin3,
    Tout (*)(const Tin1&,Tin2,const Tin3&)>(fn);
}
template<class Tout, class Tin1, class Tin2, class Tin3> 
inline PipeModuleLift3<Tout, Tin1, Tin2, Tin3, 
  Tout (*)(const Tin1&,const Tin2&,Tin3)> 
liftP( Tout (*fn)(const Tin1&,const Tin2&,Tin3) ) {
  return PipeModuleLift3<Tout,Tin1,Tin2,Tin3,
    Tout (*)(const Tin1&,const Tin2&,Tin3)>(fn);
}
template<class Tout, class Tin1, class Tin2, class Tin3> 
inline PipeModuleLift3<Tout, Tin1, Tin2, Tin3, 
  Tout (*)(const Tin1&,const Tin2&,const Tin3&)> 
liftP( Tout (*fn)(const Tin1&,const Tin2&,const Tin3&) ) {
  return PipeModuleLift3<Tout,Tin1,Tin2,Tin3,
    Tout (*)(const Tin1&,const Tin2&,const Tin3&)>(fn);
}

// Code marked obsolete are no longer being maintained and the use
// is NOT recommended, as certain bugs may exist.
// A replacement to Functoid approach will be implemented soon

// ----------------------------------------------------------------
// Obsolete code starts 

// 2. Implicit functions, in form of Tvoid func( const Tin1&, ..., Tout& )
// or Tvoid func( Tout&, const Tin1&, ... )

template<class Tout, class Tvoid=Tout>
class PipeModuleLiftImplicit0 : public PipeLift0<Tout> {
  typedef PipeModuleLiftImplicit0<Tout,Tvoid> ThisType ;
  typedef PipeLift0<Tout> BaseType ;
 protected:  
  typedef Tvoid (*LiftImp0Type)( Tout& y );
  LiftImp0Type fn ;
  
 protected:

  void setDependency(void) {}
  ThisType * duplicate(void) const { return new ThisType(*this); }

 protected:

  inline void check(void) { PipeModule<Tout>::check( fn ); }

 public:
 
  PipeModuleLiftImplicit0( LiftImp0Type fnin ) : fn(fnin) 
    { setDependency(); }
  PipeModuleLiftImplicit0( const ThisType& p) : 
    BaseType(p), fn(p.fn) { setDependency(); }
  operator Pipe<Tout> () const { return Pipe<Tout>(duplicate()); }

  Pipe<Tout> operator ()(void) const { return Pipe<Tout>(duplicate()); }

  Tout compute_local_fn( int fc ) { check(); fn(value); return value ; }
};

template<class Tout, class Tvoid>
 inline Pipe<Tout> liftP( Tvoid (*fn)(Tout&) ) {
  return Pipe<Tout>(new PipeModuleLiftImplicit0<Tout,Tvoid>(fn)) ; 
}

template<class Tout, class Tin1, class Tvoid=Tout>
class PipeModuleLiftImplicit1 : public PipeLift1<Tout,Tin1> {
  typedef PipeModuleLiftImplicit1<Tout,Tin1,Tvoid> ThisType ;
 protected:
  typedef Tvoid (*LiftImp1Type1)( const Tin1& x1, Tout& y );
  typedef Tvoid (*LiftImp1Type2)( Tout& y, const Tin1& x1 );
  LiftImp1Type1 fn1 ;
  LiftImp1Type2 fn2 ;
  int which_fn ;
  Pipe<Tin1> *pred1 ;

 protected:

  void setDependency(void) { addDependency((DependencyUnit**)&pred1); }
  ThisType * duplicate(void) const { return new ThisType(*this); }

  inline void check(void)
    { PipeModule<Tout>::check( (which_fn==1?fn1!=0:fn2!=0) && pred1 ); }

 public:
  
  PipeModuleLiftImplicit1( LiftImp1Type1 fnin ) : 
    fn1(fnin), fn2(0), which_fn(1), pred1(0) { setDependency(); }
  PipeModuleLiftImplicit1( LiftImp1Type2 fnin ) : 
    fn1(0), fn2(fnin), which_fn(2), pred1(0) { setDependency(); }
  PipeModuleLiftImplicit1( const PipeModuleLiftImplicit1<Tout,Tin1,Tvoid>& p ):
    PipeLift1<Tout,Tin1>(p), fn1(p.fn1), fn2(p.fn2), 
    which_fn(p.which_fn), pred1(p.pred1) { setDependency(); }

  Pipe<Tout> operator () ( const Pipe<Tin1>& x1 ) const
    {
      PipeModuleLiftImplicit1<Tout,Tin1,Tvoid> *p = 
        new PipeModuleLiftImplicit1<Tout,Tin1,Tvoid>(*this) ;
      p->pred1 = new Pipe<Tin1>(x1);
      return Pipe<Tout>(p);
    }

  Tout compute_local_fn( int fc ) 
    { 
      check(); 
      if( which_fn == 1 ) {
        (*fn1)( pred1->get_value(fc), value ); 
      }else {   // which_fn == 2
        (*fn2)( value, pred1->get_value(fc) );
      }
      return value ; 
    }
};

template<class Tout, class Tin1, class Tvoid>
inline PipeModuleLiftImplicit1<Tout, Tin1, Tvoid> 
liftP( Tvoid (*fn)(const Tin1&, Tout&) ) {
  return PipeModuleLiftImplicit1<Tout,Tin1,Tvoid>(fn) ;
}

template<class Tout, class Tin1, class Tvoid>
inline PipeModuleLiftImplicit1<Tout, Tin1, Tvoid> 
liftP( Tvoid (*fn)(Tout&, const Tin1&) ) {
  return PipeModuleLiftImplicit1<Tout,Tin1,Tvoid>(fn) ;
}

// 3. Class member functions

template<class Tout, class Tclass, class Fn>
class PipeModuleLiftClass0 : public PipeLift0<Tout> {
  typedef PipeModuleLiftClass0<Tout,Tclass,Fn> ThisType ;
 protected:
  Fn fn ;
  Pipe<Tclass> * predc ;

 protected:
  void setDependency(void) { addDependency((DependencyUnit**)&predc); }
  ThisType * duplicate(void) const { return new ThisType(*this); }

  inline void check(void) 
    { PipeModule<Tout>::check( (bool)fn && predc ); }

 public:

  PipeModuleLiftClass0( Fn fnin ) : fn(fnin), predc(0) { setDependency(); }
  PipeModuleLiftClass0( const Pipe<Tclass>& p, Fn fnin ) :
    fn(fnin), predc(new Pipe<Tclass>(p)) { setDependency(); }
  PipeModuleLiftClass0( const ThisType& p ) : PipeLift0<Tout>(p),
    fn(p.fn), predc(p.predc) { setDependency(); }

  Pipe<Tout> operator ()(void) const 
    {
      ThisType *p = new ThisType(*this);
      return Pipe<Tout>(p);
    }

  Pipe<Tout> operator ()( const Pipe<Tclass>& x ) const 
    {
      if( predc ) throw RedefPipe() ;
      ThisType *p = new ThisType(*this);
      p->predc = new Pipe<Tclass>(x);
      return Pipe<Tout>(p);
    }

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

template<class Tout, class Tclass>
inline PipeModuleLiftClass0<Tout, Tclass, Tout (Tclass::*)(void)>
liftP( const Pipe<Tclass>& p, Tout (Tclass::*fn)(void) ) {
  return PipeModuleLiftClass0<Tout, Tclass, Tout (Tclass::*)(void)>( p, fn );
}
template<class Tout, class Tclass>
inline PipeModuleLiftClass0<Tout, Tclass, Tout (Tclass::*)(void)>
liftP( Tout (Tclass::*fn)(void) ) {
  return PipeModuleLiftClass0<Tout, Tclass, Tout (Tclass::*)(void)>( fn );
}
template<class Tout, class Tclass>
inline PipeModuleLiftClass0<Tout, Tclass, Tout (Tclass::*)(void) const>
liftP( const Pipe<Tclass>& p, Tout (Tclass::*fn)(void) const ) {
  return PipeModuleLiftClass0<Tout, Tclass, 
    Tout (Tclass::*)(void) const>( p, fn );
}
template<class Tout, class Tclass>
inline PipeModuleLiftClass0<Tout, Tclass, Tout (Tclass::*)(void) const>
liftP( Tout (Tclass::*fn)(void) const ) {
  return PipeModuleLiftClass0<Tout, Tclass,
    Tout (Tclass::*)(void) const>( fn );
}

template<class Tout, class Tclass, class Tin1, class Fn>
class PipeModuleLiftClass1 : public PipeModule<Tout> {
  typedef PipeModuleLiftClass1<Tout,Tclass,Tin1,Fn> ThisType ;
 protected:
  Fn fn ;
  Pipe<Tclass> * predc ;
  Pipe<Tin1> * pred1 ;

 protected:
  void setDependency(void) 
    { 
      addDependency((DependencyUnit**)&predc); 
      addDependency((DependencyUnit**)&pred1); 
    }
  ThisType * duplicate(void) const { return new ThisType(*this); }

  inline void check(void) 
    { PipeModule<Tout>::check( (bool)fn && predc && pred1 ); }

 public:

  PipeModuleLiftClass1( Fn fnin ) : 
    fn(fnin), predc(0), pred1(0) { setDependency(); }
  PipeModuleLiftClass1( const ThisType& p ) : PipeModule<Tout>(p),
    fn(p.fn), predc(p.predc), pred1(p.pred1) { setDependency(); }

  Pipe<Tout> operator ()( const Pipe<Tclass>& t, const Pipe<Tin1>& x1 ) const 
    {
      ThisType *p = new ThisType(*this);
      p->predc = new Pipe<Tclass>(t);
      p->pred1 = new Pipe<Tin1>(x1);
      return Pipe<Tout>(p);
    }

  Tout compute_local_fn( int fc )
    { check(); return (predc->get_value(fc).*fn)(pred1->get_value(fc)); }
};

template<class Tout, class Tclass, class Tin1>
inline PipeModuleLiftClass1<Tout, Tclass, Tin1, Tout (Tclass::*)(Tin1)>
liftP( Tout (Tclass::*fn)(Tin1) ) {
  return PipeModuleLiftClass1<Tout, Tclass, Tin1, 
    Tout (Tclass::*)(Tin1)>( fn );
}
template<class Tout, class Tclass, class Tin1>
inline PipeModuleLiftClass1<Tout, Tclass, Tin1, Tout (Tclass::*)(const Tin1&)>
liftP( Tout (Tclass::*fn)(const Tin1&) ) {
  return PipeModuleLiftClass1<Tout, Tclass, Tin1, 
    Tout (Tclass::*)(const Tin1&)>( fn );
}

// PipeModeleClassLift -- Tclass is not pipe here, different from above

template<class Tout, class Tclass, class Fn>
class PipeModuleClassLift0 : public PipeModule<Tout> {
  typedef PipeModuleClassLift0<Tout,Tclass,Fn> ThisType;
 protected:
  Tclass host ;
  Fn fn ;

 protected:

  void setDependency(void) {}
  ThisType * duplicate(void) const { return new ThisType(*this);}

 protected:

  inline void check(void) { PipeModule<Tout>::check( fn ); }

 public:

  PipeModuleClassLift0( const Tclass& obj, Fn fnin ) : host(obj), fn(fnin) 
    { setDependency(); }
  PipeModuleClassLift0( const ThisType& p ) : PipeModule<Tout>(p),
    host(p.host), fn(p.fn) { setDependency(); }

  operator Pipe<Tout> () const 
    { return Pipe<Tout>(new ThisType(*this)); }

  Pipe<Tout> operator ()(void) const
    { ThisType *p = new ThisType(*this) ; return Pipe<Tout>(p) ; }

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

template<class Tout, class Tclass> 
inline Pipe<Tout> liftP( const Tclass& obj, Tout (Tclass::*fn)(void) ) {
  return Pipe<Tout>(new PipeModuleClassLift0
              <Tout,Tclass,Tout (Tclass::*)(void)>(obj,fn));
}
template<class Tout, class Tclass> 
inline Pipe<Tout> liftP( const Tclass& obj, Tout (Tclass::*fn)(void) const ) {
  return Pipe<Tout>(new PipeModuleClassLift0
              <Tout,Tclass,Tout (Tclass::*)(void) const>(obj,fn));
}

template<class Tout, class Tin1, class Tclass, class Fn>
class PipeModuleClassLift1 : public PipeLift1<Tout,Tin1> {
  typedef PipeModuleClassLift1<Tout,Tin1,Tclass,Fn> ThisType;
 protected:
  Tclass host ;
  Fn fn ;
  Pipe<Tin1> * pred1 ;

 protected:

  void setDependency(void) { addDependency((DependencyUnit**)&pred1); }
  ThisType * duplicate(void) const { return new ThisType(*this);}

  inline void check(void) { PipeModule<Tout>::check( (bool)fn && pred1 ); }

 public:

  PipeModuleClassLift1( const Tclass& obj, Fn fnin ) : 
    host(obj), fn(fnin), pred1(0) { setDependency(); }
  PipeModuleClassLift1( const ThisType& p ) : PipeLift1<Tout,Tin1>(p),
    host(p.host), fn(p.fn), pred1(p.pred1) { setDependency(); }

  Pipe<Tout> operator ()( const Pipe<Tin1>& x1 ) const
    { 
      ThisType *p = new ThisType(*this) ; 
      p->pred1 = new Pipe<Tin1>(x1) ;
      return Pipe<Tout>(p) ; 
    }

  Tout compute_local_fn( int fc ) 
    { check(); return (host.*fn)(pred1->get_value(fc)); }
};

template<class Tout, class Tin, class Tclass> 
inline PipeModuleClassLift1<Tout,Tin,Tclass,Tout (Tclass::*)(Tin)>
liftP( const Tclass& obj, Tout (Tclass::*fn)(Tin) ) {
  return PipeModuleClassLift1 <Tout,Tin,Tclass,Tout (Tclass::*)(Tin)>(obj,fn);
}
template<class Tout, class Tin, class Tclass> 
inline PipeModuleClassLift1<Tout,Tin,Tclass,Tout (Tclass::*)(Tin) const>
liftP( const Tclass& obj, Tout (Tclass::*fn)(Tin) const ) {
  return PipeModuleClassLift1
    <Tout,Tin,Tclass,Tout (Tclass::*)(Tin) const>(obj,fn);
}
template<class Tout, class Tin, class Tclass> 
inline PipeModuleClassLift1<Tout,Tin,Tclass,Tout (Tclass::*)(const Tin&)>
liftP( const Tclass& obj, Tout (Tclass::*fn)(const Tin&) ) {
  return PipeModuleClassLift1
    <Tout,Tin,Tclass,Tout (Tclass::*)(const Tin&)>(obj,fn);
}
template<class Tout, class Tin, class Tclass> 
inline PipeModuleClassLift1
  <Tout,Tin,Tclass,Tout (Tclass::*)(const Tin&) const>
liftP( const Tclass& obj, Tout (Tclass::*fn)(const Tin&) const ) {
  return PipeModuleClassLift1
    <Tout,Tin,Tclass,Tout (Tclass::*)(const Tin&) const>(obj,fn);
}

// Obsolete code ends...
// --------------------------------------------------------------------

// Lift for date member

template<class Tout, class Tclass>
inline PipeModuleLift1<Tout,Tclass,XVDataMemFun<Tout Tclass::*,Tout,Tclass> >
liftP( Tout Tclass::*f ) {
  return PipeModuleLift1<Tout,Tclass,XVDataMemFun<Tout Tclass::*,Tout,Tclass> >
    (XVDataMemFun<Tout Tclass::*,Tout,Tclass>(f));
}

template<class T1, class T2>
inline T1 implicitCast( const T2& x ) {
  return x ;
}

template <class T1, class T2>
inline Pipe<T1> castP( const Pipe<T2>& x ) {
  PipeModuleLift1<T1,T2,T1 (*)(const T2&)> cast(implicitCast<T1,T2>);
  return cast(x) ;
}

// Delay module, basically just pass frame_count-1 down

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

  //bool been_called ;
  T next ;
  Pipe<T> *pred ;

 protected:

  void setDependency(void) { addDependency((DependencyUnit**)&pred); }
  PipeDelay<T> * duplicate(void) const { return new PipeDelay<T>(*this); }

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

 public:

  PipeDelay( const T& x ) : next(x), pred(0) { setDependency(); }
  PipeDelay( const PipeDelay<T>& p ) : PipeModule<T>(p), 
    next(p.next), pred(p.pred) { setDependency(); }

  Pipe<T> operator () ( const Pipe<T>& x ) const
    { 
      PipeDelay<T> *p = new PipeDelay<T>(*this);
      p->pred = new Pipe<T>(x) ; 
      return Pipe<T>(p); 
    }

  void get_value( int fc, T * addr ) { *addr = get_value( fc ); }

  T get_value( int fc )
    {
      if( fc != frame_count ) {
     check();
     value = next ;
     frame_count = fc ;
     update( frame_count, value );
     pred->get_value( fc, &next ); 
      }
      return value ;
    }
};

template<class T>
inline PipeDelay<T> delayP( const T& x ) {
  return PipeDelay<T>(x) ;
}

// Pipe operator <<=

template<class T1, class T2>
inline typename T1::ResultType 
operator <<= ( const T1& x1, const T2& x2 ) {
  return x1(x2);
}

// Pipe operator >>=, means connect two pipes but only use data from second one

template<class T1, class T2>
inline T2 useSecondPipe( const T1&, const T2& x2 ) { return x2 ; }

template<class T1, class T2>
inline Pipe<T2> operator >>= ( const Pipe<T1>& p1, const Pipe<T2>& p2 ) {
  PipeModuleLift2<T2,T1,T2,T2 (*)(const T1&,const T2&)> p(useSecondPipe<T1,T2>);
  return p( p1, p2 ) ;
}

# define PARALLEL_P >>=

// 4. Binary operators
// Here the assumption is that the return type of binary operators
// is same as its first operand. 

#define LiftBinOp(OP,NM) \
template<class Tout, class Tin1, class Tin2>\
class PipeModuleLiftBin##NM: public PipeModule<Tout> {\
  typedef PipeModuleLiftBin##NM<Tout,Tin1,Tin2> ThisType ; \
 protected:\
  Pipe<Tin1> *pred1; \
  Pipe<Tin2> *pred2; \
\
 protected:\
  void setDependency(void) \
  { \
    addDependency((DependencyUnit**)&pred1); \
    addDependency((DependencyUnit**)&pred2); \
  } \
  ThisType * duplicate(void) const { return new ThisType(*this); } \
\
  inline void check(void) { PipeModule<Tout>::check( pred1 && pred2 ); }\
\
 public:\
\
  PipeModuleLiftBin##NM(const Pipe<Tin1>& x, const Pipe<Tin2>& y) : \
   PipeModule<Tout>(), pred1(new Pipe<Tin1>(x)), pred2(new Pipe<Tin2>(y)) \
   { setDependency(); } \
  PipeModuleLiftBin##NM( const ThisType& p) : \
   PipeModule<Tout>(p), pred1(p.pred1), pred2(p.pred2) \
   { setDependency(); } \
\
  Tout compute_local_fn(int fc) \
      { check(); return pred1->get_value(fc) OP pred2->get_value(fc) ; } \
};\
\
template <class T1, class T2>\
Pipe<T1> operator OP(const Pipe<T1>& x, const Pipe<T2>& y)\
{\
  return Pipe<T1>(new PipeModuleLiftBin##NM<T1,T1,T2>(x,y));\
}\
template <class T1, class T2>\
Pipe<T1> operator OP( const Pipe<T1>& x, const T2 y)\
{\
  return Pipe<T1>(new PipeModuleLiftBin##NM<T1,T1,T2>(x,y));\
}\
template <class T1, class T2>\
Pipe<T1> &operator OP(const T1 x, const Pipe<T2>& y)\
{\
  return Pipe<T1>(new PipeModuleLiftBin##NM<T1,T1,T2>(x,y));\
}\

LiftBinOp(+,Plus);
LiftBinOp(-,Minus);
LiftBinOp(*,Multiply);
LiftBinOp(/,Divide);
LiftBinOp(<<,LeftShift);
LiftBinOp(>>,RightShift);
//LiftBinOp(&&,LogicalAnd);
//LiftBinOp(||,LogicalOr);
LiftBinOp(&,BitwiseAnd);
LiftBinOp(|,BitWiseOr);

// Unary operators
// Here the assumption is that the return type of unary operators
// is same as its operand. 

#define LiftUnOp(OP,NM) \
template<class T>\
class PipeModuleLiftUn##NM: public PipeModule<T> {\
  typedef PipeModuleLiftUn##NM<T> ThisType ; \
 protected:\
  Pipe<T> *pred; \
\
 protected:\
  void setDependency(void) { addDependency((DependencyUnit**)&pred); } \
\
  ThisType * duplicate(void) const { return new ThisType(*this); } \
\
  inline void check(void) { PipeModule<T>::check( pred ); }\
\
 public:\
\
  PipeModuleLiftUn##NM( const Pipe<T>& x ) : \
   PipeModule<T>(), pred(new Pipe<T>(x)) { setDependency(); } \
  PipeModuleLiftUn##NM( const ThisType& p ) : \
   PipeModule<T>(p), pred(p.pred) { setDependency(); } \
\
  T compute_local_fn(int fc) { check(); return OP pred->get_value(fc); } \
};\
\
template<class T> \
inline Pipe<T> operator OP ( const Pipe<T>& x ) { \
  return Pipe<T>(new PipeModuleLiftUn##NM<T>(x)) ; \
} \

LiftUnOp(!,Not)

// Pipe function classes

// PipeFun classes represent a pipe function object. After declare 
// their instances, user must define them either by giving both their 
// formal parameters and function bodies, or assign from lambda expressions.
// After that, the function objects can evaluate to construct a graph.
// formal parameters can list as constructor parameters, or at the left hand 
// of equation followed by NULL, e.g. f(x,NULL) = x * 2 ;

template<class Tout>
class PipeFun0 : public PipeLift0<Tout> {
  typedef PipeFun0<Tout> ThisType ;
  typedef PipeLift0<Tout> BaseType ;
 protected:
  Pipe<Tout> * result ;

 protected:  
  void setDependency(void) 
    { addDependency((DependencyUnit**)&result); }
  ThisType * duplicate(void) const { return new ThisType(*this); }  

  inline void check(void) { return PipeModule<Tout>::check(result);}

 public:
  PipeFun0() : result(0) { setDependency(); }
  PipeFun0( const ThisType& p ) : BaseType(p), 
    result(p.result) { setDependency(); }

  Pipe<Tout> operator() (void)
    { 
      check(); 
      ThisType *p = (ThisType *) copy();
      return Pipe<Tout>(p) ;
    }

  // this function hacks... 
  Pipe<Tout> operator() (void) const 
    { return (*const_cast<ThisType*>(this))() ; }

  ThisType& operator = ( const Pipe<Tout>& p )
    { 
      if( result ) throw RedefPipe() ;
      result = new Pipe<Tout>(p) ;
      return *this; 
    }

  ThisType& operator = ( const ThisType& p )
    { 
      if( &p != this ) {
        if( result ) throw RedefPipe() ;
        result = p.result ; 
        return *this; 
      }
    }

  Tout get_value( int fc ) { check(); return result->get_value(fc); }
};

template<class Tout>
PipeFun0<Tout> 
lambdaP( const Pipe<Tout>& f ) {
  PipeFun0<Tout> p;
  return p = f ;
}

template<class Tout, class Tin1>
class PipeFun1 : public PipeLift1<Tout,Tin1> {
  typedef PipeFun1<Tout,Tin1> ThisType ;
  typedef PipeLift1<Tout,Tin1> BaseType ;
 protected:
  Pipe<Tout> * result ;
  Pipe<Tin1> * param1 ;

 protected:
  
  void setDependency(void) 
    { 
      addDependency((DependencyUnit**)&result); 
      addDependency((DependencyUnit**)&param1); 
    }
  ThisType * duplicate(void) const { return new ThisType(*this); }  

  inline void check(void) { return PipeModule<Tout>::check(result&&param1);}

 public:
  PipeFun1() : result(0), param1(0) { setDependency(); }
  PipeFun1( Pipe<Tin1>& p1 ) : result(0), param1(&p1) {setDependency();}
  PipeFun1( const ThisType& p ) : BaseType(p), 
    result(p.result), param1(p.param1) { setDependency(); }

  ThisType& operator () ( Pipe<Tin1>& p1, void * dummy ) 
    {
      if( param1 ) throw RedefPipe() ;
      param1 = &p1 ;
      return *this ;
    }

  Pipe<Tout> operator() ( const Pipe<Tin1>& x1 )
    { 
      check(); 
      PipeModule<Tin1> dummy1, * save1 = *(param1->module) ;
      *(param1->module) = &dummy1 ;
      ThisType *p = (ThisType *) copy();
      delete *(p->param1->module) ; // assume PipeModule->duplicate() use new
      *(p->param1->module) = new Pipe<Tin1>(x1) ;
      *(param1->module) = save1 ;
      return Pipe<Tout>(p) ;
    }

  // this function hacks... 
  Pipe<Tout> operator() ( const Pipe<Tin1>& x1 ) const 
    { return (*const_cast<ThisType*>(this))(x1) ; }

  ThisType& operator = ( const Pipe<Tout>& p )
    { 
      if( result ) throw RedefPipe() ;
      result = new Pipe<Tout>(p) ;
      return *this; 
    }

  ThisType& operator = ( const ThisType& p )
    { 
      if( &p != this ) {
        if( result || param1 ) throw RedefPipe() ;
        result = p.result ; 
        param1 = p.param1 ; 
        return *this; 
      }
    }

  Tout get_value( int fc ) { check(); return result->get_value(fc); }
};

template<class Tout, class Tin1>
PipeFun1<Tout,Tin1> 
lambdaP( Pipe<Tin1>& x1, const Pipe<Tout>& f ) {
  PipeFun1<Tout,Tin1> p(x1);
  return p = f ;
}

template<class Tout, class Tin1, class Tin2>
class PipeFun2 : public PipeLift2<Tout,Tin1,Tin2> {
  typedef PipeFun2<Tout,Tin1,Tin2> ThisType ;
  typedef PipeLift2<Tout,Tin1,Tin2> BaseType ;
 protected:
  Pipe<Tout> * result ;
  Pipe<Tin1> * param1 ;
  Pipe<Tin2> * param2 ;

 protected:
  
  void setDependency(void) 
    { 
      addDependency((DependencyUnit**)&result); 
      addDependency((DependencyUnit**)&param1); 
      addDependency((DependencyUnit**)&param2); 
    }
  ThisType * duplicate(void) const { return new ThisType(*this); }  

  inline void check(void) 
    { return PipeModule<Tout>::check(result&&param1&&param2);}

 public:
  PipeFun2() : result(0), param1(0), param2(0) { setDependency(); }
  PipeFun2( Pipe<Tin1>& p1, Pipe<Tin2>&p2 ) : result(0), 
    param1(&p1), param2(&p2) {setDependency();}
  PipeFun2( const ThisType& p ) : BaseType(p), result(p.result), 
    param1(p.param1), param2(p.param2) { setDependency(); }

  ThisType& operator () ( Pipe<Tin1>& p1, Pipe<Tin2>& p2, void * dummy ) 
    {
      if( param1 || param2 ) throw RedefPipe() ;
      param1 = &p1 ;
      param2 = &p2 ;
      return *this ;
    }

  Pipe<Tout> operator() ( const Pipe<Tin1>& x1, const Pipe<Tin2>& x2 )
    { 
      check(); 
      PipeModule<Tin1> dummy1, * save1 = *(param1->module) ;
      *(param1->module) = &dummy1 ;
      PipeModule<Tin2> dummy2, * save2 = *(param2->module) ;
      *(param2->module) = &dummy2 ;
      ThisType *p = (ThisType *) copy();
      delete *(p->param1->module) ; // assume PipeModule->duplicate() use new
      *(p->param1->module) = new Pipe<Tin1>(x1) ;
      *(param1->module) = save1 ;
      delete *(p->param2->module) ; // assume PipeModule->duplicate() use new
      *(p->param2->module) = new Pipe<Tin2>(x2) ;
      *(param2->module) = save2 ;
      return Pipe<Tout>(p) ;
    }

  // this function hacks... 
  Pipe<Tout> operator() ( const Pipe<Tin1>& x1, const Pipe<Tin2>& x2 ) const 
    { return (*const_cast<ThisType*>(this))(x1,x2) ; }

  ThisType& operator = ( const Pipe<Tout>& p )
    { 
      if( result ) throw RedefPipe() ;
      result = new Pipe<Tout>(p) ;
      return *this; 
    }

  ThisType& operator = ( const ThisType& p )
    { 
      if( &p != this ) {
        if( result || param1 || param2 ) throw RedefPipe() ;
        result = p.result ; 
        param1 = p.param1 ; 
        param2 = p.param2 ; 
        return *this; 
      }
    }

  Tout get_value( int fc ) { check(); return result->get_value(fc); }
};

template<class Tout, class Tin1, class Tin2>
PipeFun2<Tout,Tin1,Tin2> 
lambdaP( Pipe<Tin1>& x1, Pipe<Tin2>& x2, const Pipe<Tout>& f ) {
  PipeFun2<Tout,Tin1,Tin2> p(x1, x2);
  return p = f ;
}

// We need more work on PipeFun3, etc. basically "copy and paste" codes 
// -- Donald


// Pair class

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) {};

  T1 lVal(void) const { return lval ; }
  T2 rVal(void) const { return rval ; }
};

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

template <class T1, class T2>
Pipe< Pair<T1,T2> > operator&&( const Pipe<T1>& x, const Pipe<T2>& y)
{
  Pair<T1,T2> (*Pairupf)( T1, T2 ) = &Pairup;
  PipeModuleLift2<Pair<T1,T2>,T1,T2,Pair<T1,T2> (*)(T1,T2)> temp(Pairupf);

  return temp(x,y);
}

# endif //_PIPEMODULES_H_

---