---

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

# ifndef _PIPEEVENTS_H_
# define _PIPEEVENTS_H_

# include "PipeModules.h"

// Events are basically synchronous, which means possibly to compute for 
// a value which is never used. We'll have asynchronous version soon.

// Helper functions

template<class T>
class Maybe : protected Pair<bool,T> {
 public:
  Maybe() : Pair<bool,T>() { lval = false ; }
  Maybe( const T& x ) : Pair<bool,T>(true,x) {}
  Maybe( bool f, const T& x ) : Pair<bool,T>(f,x) {}
  Maybe( const Maybe<T>& x ) : Pair<bool,T>(x) {}
  Maybe<T>& operator = (const Maybe<T>& x) 
    {
      if( &x != this ) {
     if( lval = x.lval ) {
       rval = x.rval ;
     }
      }
      return *this ;
    }

  bool hasValue(void) const { return lval ; }
  T getValue(void) const { return rval ; }
  operator bool () const { return hasValue(); }
  bool operator ! () const { return !hasValue(); }
  T operator *() const { return getValue(); }
};

template<class T>
inline Maybe<T> maybePair( bool f, const T& x ) {
  return Maybe<T>(f,x);
}
// Caution -- PipeModuleLift implementaion dependent!
template<class T>
inline Pipe<Maybe<T> > maybeP( const Pipe<bool>& x1, const Pipe<T>& x2 ) {
  PipeModuleLift2<Maybe<T>,bool,T,Maybe<T> (*)(bool, const T&)> pair
    (maybePair<T>) ;
  return pair(x1,x2);
}

template<class T1, class T2>
Maybe<Pair<T1,T2> > maybeAnd ( const Maybe<T1>& x1, 
                      const Maybe<T2>& x2 ) {
  if( x1 && x2 ) {
    return Maybe<Pair<T1,T2> >(Pair<T1,T2>(*x1,*x2));
  }else {
    return Maybe<Pair<T1,T2> >();
  }
}

template<class T1, class T2>
Maybe<Pair<T1,T2> > maybeOr ( const Maybe<T1>& x1, 
                     const Maybe<T2>& x2 ) {
  if( x1 || x2 ) {
    return Maybe<Pair<T1,T2> >(Pair<T1,T2>(*x1,*x2));
  }else {
    return Maybe<Pair<T1,T2> >();
  }
}

// PipeEvents is a stream of events, each of them contains a data pack

template<class T>
class PipeEvents : public Pipe<Maybe<T> > {
 protected:

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

 public:

  PipeEvents() : Pipe<Maybe<T> >() {}
  PipeEvents( const PipeEvents<T>& p ) : Pipe<Maybe<T> >(p) {}
  PipeEvents( const Pipe<Maybe<T> >& p ) : Pipe<Maybe<T> >(p) {}
  PipeEvents( PipeModule<Maybe<T> > *v ) : Pipe<Maybe<T> >(v) {}

  PipeEvents<T>& operator = ( const PipeEvents<T>& p )
    { Pipe<Maybe<T> >::operator = (p); return *this ; }
  PipeEvents<T>& operator = ( const Pipe<Maybe<T> >& p )
    { Pipe<Maybe<T> >::operator = (p); return *this ; }

  bool hasValue(void) { return current_value().hasValue() ; }
  bool hasValue( int fc ) { return get_value(fc).hasValue() ; }
  T getValue( int fc ) { return get_value(fc).getValue() ; }
};

// whileP is a direct way to convert Pipe to PipeEvents
template<class T, class Fn>
inline PipeEvents<T> whileP( Fn fn, const Pipe<T>& p ) {
  return PipeEvents<T>( maybeP<T>( liftP(fn)(p), p ) );
}

inline PipeEvents<bool> whileP( const Pipe<bool>& p ) {
  return PipeEvents<bool>( maybeP<bool>( p, p ) );
}

// auxiliary class for whileP

template<class T, class Fn>
class PipeWhileModule : XVFunctoid1<Fn,PipeEvents<T>,Pipe<T> > {
  typedef XVFunctoid1<Fn,PipeEvents<T>,Pipe<T> > BaseType ;
 public:
  PipeWhileModule( Fn fn ) : BaseType(fn) {}
  virtual PipeEvents<T> operator () ( const Pipe<T>& x )
    { return maybeP<T>( liftP(f)(x), x ) ; }
};

template<class T, class Fn>
inline PipeWhileModule<T,Fn> whileP( Fn fn ) {
  return PipeWhileModule<T,Fn>(fn);
}
template<class T>
inline PipeWhileModule<T,bool (*)(T)> whileP( bool (*fn)(T) ) {
  return PipeWhileModule<T,bool (*)(T)>(fn);
}
template<class T>
inline PipeWhileModule<T,bool (*)(const T&)> whileP( bool (*fn)(const T&) ) {
  return PipeWhileModule<T,bool (*)(const T&)>(fn);
}

// uniqueP, suppress duplicate successive events in an event pipe

template<class T>
Maybe<T> maybeNotAnd ( const Maybe<T>& x1, const Maybe<T>& x2 ) {
  if( !x1 && x2 ) {
    return x2;
  }else {
    return Maybe<T>(/*false*/);
  }
}

template<class T>
inline PipeEvents<T> uniqueP( const PipeEvents<T>& p ) {
  typedef Maybe<T> MT ;
  PipeModuleLift2<MT,MT,MT,MT (*)(const MT&,const MT&)> ufun(maybeNotAnd<T>) ;
  return ufun( delayP(Maybe<T>()) <<= p, p ) ;
}

// WhenP = uniqueP(whileP)

template<class T, class Fn>
class PipeWhenModule : XVFunctoid1<Fn,PipeEvents<T>,Pipe<T> > {
  typedef XVFunctoid1<Fn,PipeEvents<T>,Pipe<T> > BaseType ;
 public:
  PipeWhenModule( Fn fn ) : BaseType(fn) {}
  virtual PipeEvents<T> operator () ( const Pipe<T>& x )
    { return uniqueP( PipeEvents<T>( maybeP<T>( liftP(f)(x), x ) ) ); }
};

template<class T, class Fn>
inline PipeWhenModule<T,Fn> whenP( Fn fn ) {
  return PipeWhenModule<T,Fn>(fn);
}
template<class T>
inline PipeWhenModule<T,bool (*)(T)> whenP( bool (*fn)(T) ) {
  return PipeWhenModule<T,bool (*)(T)>(fn);
}
template<class T>
inline PipeWhenModule<T,bool (*)(const T&)> whenP( bool (*fn)(const T&) ) {
  return PipeWhenModule<T,bool (*)(const T&)>(fn);
}

// thenP, same as -=> in frp, use operator |= here

// We have three version of then/until: statical and dynamical, and functional,
// indicated by postfix s, d and f respectivly.
// statical version wastes computation, while dynamical one wastes memory
// without a garbage collector. Functional one always creates new pipe when 
// switched to, so it can't be used to switch back again to the same pipe.
// The default one is statical. Functional version is not implemented yet.

template<class T1, class T2>
PipeEvents<T2> thenPs( const PipeEvents<T1>& e, const Pipe<T2>& p ) {
  return maybeP( liftP(&Maybe<T1>::hasValue)(e), p );
}

template<class T1, class T2>
PipeEvents<Pipe<T2>*> thenPd( const PipeEvents<T1>& e, const Pipe<T2>& p ) {
  return maybeP( liftP(&Maybe<T1>::hasValue)(e), 
           Pipe<Pipe<T2>*>(new Pipe<T2>(p)) );
}

template<class T1, class T2>
inline PipeEvents<T2> thenP( const PipeEvents<T1>& e, const Pipe<T2>& p ) {
  return thenPs(e,p) ;
}

template<class T1, class T2>
inline PipeEvents<T2> 
operator |= ( const PipeEvents<T1>& e, const Pipe<T2>& p ) {
  return thenP( e, p );
}

// switchP, or *= for `until` in frp

template<class T>
T switchFunS( const Maybe<T>& x1, const T& x2 ) {
  if( x1 ) {
    return x1.getValue() ;
  }else {
    return x2 ;
  }
}

// Caution -- PipeModuleLift implementaion dependent!
template<class T>
inline Pipe<T> switchPs( const Pipe<T>& p, const PipeEvents<T>& e ) {
  PipeModuleLift2<T,Maybe<T>,T,T (*)(const Maybe<T>&, const T&)> sfun
    (switchFunS<T>) ;
  return sfun( e, p );
}

template<class T>
class SwitchFunD : public XVFunctoid2<int,T,T,Maybe<Pipe<T>*> >{
  typedef XVFunctoid2<int,T,T,Maybe<Pipe<T>*> > BaseType ;
public:
  SwitchFunD( int fc ) : BaseType(fc) {}
  int set( int fc ) { return f = fc ; }
  operator bool (void) { return true ; }
  T operator ()( const T& x, const Maybe<Pipe<T>*>& e ) 
    { if( e ) return e.getValue()->get_value(f) ; else return x ; }
};


template<class T>
class PipeModuleSwitchD : 
 public PipeModuleLift2<T,T,Maybe<Pipe<T>*>,SwitchFunD<T> > {
  typedef PipeModuleSwitchD<T> ThisType ;
  typedef PipeModuleLift2<T,T,Maybe<Pipe<T>*>,SwitchFunD<T> > BaseType ;
 protected:
  ThisType * duplicate(void) const { return new ThisType(*this); }
 public:
  PipeModuleSwitchD() : BaseType(0) {}
  PipeModuleSwitchD( const ThisType& p ) : BaseType(p) {}
  T compute_local_fn( int fc ) 
    { return BaseType::compute_local_fn( fn.set(fc) ) ; }
};

template<class T>
inline Pipe<T> switchPd( const Pipe<T>& p, const PipeEvents<Pipe<T>*>& e ) {
  PipeModuleSwitchD<T> sfun ;
  return sfun(p,e);
}

/*
template<class T>
class PipeModuleSwitchD : public PipeLift2<T,T,Maybe<Pipe<T> > > {
  typedef PipeModuleSwitchD<T> ThisType ;
  typedef PipeLift2<T,T,Maybe<Pipe<T> > > BaseType ;
  typedef T Tin1 ;
  typedef Maybe<Pipe<T> > Tin2 ;
 protected:
  Pipe<Tin1> * pred1 ;
  Pipe<Tin2> * pred2 ;

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

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

 public:
  PipeModuleSwitchD() : pred1(0), pred2(0), switched(false)
    { setDependency(); } 
  PipeModuleSwitchD( const ThisType& p ) : 
    BaseType(p), pred1(p.pred1), pred2(p.pred2), switched(p.switched)
    { setDependency(); } 

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

  Tout compute_local_fn( int fc ) 
    { 
      check(); 
      Tin2 = pred2->get_value(fc) ;
      if( switched ) {
     return Tin2.getValue().get_value(fc) ;
      }else {
     return pred1->get_value(fc) ;
      }
    }
};
*/

template<class T>
inline Pipe<T> switchP( const Pipe<T>& p, const PipeEvents<T>& e ) {
  return switchPs( p, e );
}

template<class T>
inline Pipe<T> 
operator *= ( const Pipe<T>& p, const PipeEvents<T>& e ) {
  return switchP( p, e );
}

# define SWITCH_P *=

// PipeEvents operations

template<class T1, class T2>
PipeEvents<Pair<T1,T2> > operator && ( const PipeEvents<T1>& x1,
                           const PipeEvents<T2>& x2 ) {
  return PipeEvents<Pair<T1,T2> >( liftP(maybeAnd<T1,T2>)(x1,x2) );
}
template<class T1, class T2>
PipeEvents<Pair<T1,T2> > operator || ( const PipeEvents<T1>& x1,
                           const PipeEvents<T2>& x2 ) {
  return PipeEvents<Pair<T1,T2> >( liftP(maybeOr<T1,T2>)(x1,x2) );
}

template<class T>
class PipeEventOnce : public PipeModule<Maybe<T> > {
  typedef PipeEventOnce<T> ThisType ;
  typedef PipeModule<Maybe<T> > BaseType ;
 protected:
  Maybe<T> happened ;
  PipeEvents<T> * pred ;

 protected:

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

 public:
  PipeEventOnce( const PipeEvents<T>& x ) :
    happened(/*false*/), pred(new PipeEvents<T>(x)) { setDependency(); }
  PipeEventOnce( const ThisType& e ) : BaseType(e), 
    happened(e.happened), pred(e.pred) { setDependency(); }

  Maybe<T> compute_local_fn( int fc ) 
    {
      if( !happened ) {
     happened = pred->get_value(fc);
      }
      return happened ;
    }
};

template<class T>
PipeEvents<T> onceP( const PipeEvents<T>& p ) {
  return PipeEvents<T>(new PipeEventOnce<T>(p));
}

template<class T>
class PipeEventNth : public PipeModule<Maybe<T> > {
  typedef PipeEventNth<T> ThisType ;
  typedef PipeModule<Maybe<T> > BaseType ;
 protected:
  int n, c ;
  PipeEvents<T> * pred ;

 protected:

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

 protected:

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

 public:
  PipeEventNth( int nth ) : n(nth), c(0), pred(0) { setDependency(); }
  PipeEventNth( const ThisType& e ) : BaseType(e),
    n(e.n), c(e.c), pred(e.pred) { setDependency(); }

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

  Maybe<T> compute_local_fn( int fc ) 
    {
      check();
      if( c < n && pred->get_value(fc) && ++c == n ) {
     return pred->get_value(fc);
      }else {
     return Maybe<T>(/*false*/);
      }
    }
};

template<class T>
PipeEventNth<T> nthP( int n ) {
  return PipeEventNth<T>(n);
}
template<class T>
inline PipeEvents<T> 
operator <<= ( const PipeEventNth<T>& m, const PipeEvents<T>& p ){
  return m(p);
}

/* Old code

// whenP is a direct way to convert Pipe to PipeEvents

template<class T, class Fn>
PipeEvents<T> whenP( const Pipe<T>& p, Fn fn ) {
  return PipeEvents<T>( liftP(maybePair<T>)( liftP(fn)(p), p ) );
}
template<class T>
PipeEvents<T> whenP( const Pipe<bool>& flag, const Pipe<T>& data ) {
  return PipeEvents<T>( liftP(maybePair<T>)( falg, data ) );
}
template<class T>
PipeEvents<T> whenP( const Pipe<Maybe<T> >& p ) {
  return PipeEvents<T>(p);
}

// Switch -- basic unit for events affect pipe's behavior

template<class Tout, class Tvoid>
class PipeModuleSwitch : public PipeModule<Tout> {
  typedef PipeModuleSwitch<Tout,Tvoid> ThisType ;
 protected:
  bool sync ;   // whether the switch is a synchronous one or not
  PipeEvents<Tvoid> * events ;
  Pipe<Tout> * pred1 ;
  Pipe<Tout> * pred2 ;

 protected:

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

 protected:

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

 public:
  
  PipeModuleSwitch( const PipeEvents<Tvoid>& e, bool s=false ) : 
    sync(s), events(new PipeEvents<Tvoid>(e)), pred1(0), pred2(0) 
    { setDependency(); }
  PipeModuleSwitch( const ThisType& s ) : PipeModule<Tout>(s), 
    sync(s.sync), events(s.events), pred1(s.pred1), pred2(s.pred2) 
    { setDependency(); }

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

  Tout compute_local_fn( int fc ) 
    { 
      check(); 
      return events->hasValue(fc)?pred1->get_value(fc):pred2->get_value(fc);
    }
};

template<class Tout, class Tvoid>
PipeModuleSwitch<Tout, Tvoid> 
switchP( const PipeEvents<Tvoid>& events, bool sync=false ) {
  return PipeModuleSwitch<Tout, Tvoid>( events, sync );
}
template<class Tout, class Tvoid>
Pipe<Tout> 
switchP( const PipeEvents<Tvoid>& events, const Pipe<Tout>& x1,
      const Pipe<Tout>& x2, bool sync=false ) {
  return PipeModuleSwitch<Tout, Tvoid>( events, sync )( x1, x2 );
}

// PipeUntil -- a new pipe is created each time

template<class Tout, class Tevent, class Fn>
class PipeModuleUntil : public PipeModule<Tout> {
  typedef PipeModuleUntil<Tout,Tevent,Fn> ThisType ;
 protected:
  Fn fn ;
  PipeEvents<Tevent> * events ;
  Pipe<Tout> * pred ;

 protected:

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

 protected:

  inline void check(void)
    { PipeModule<Tout>::check( events && pred ); }

 public:

  PipeModuleUntil( const PipeEvents<Tevent>& e, Fn fnin ) :
    fn(fnin), events(new PipeEvents<Tevent>(e)), pred(0) { setDependency(); }
  PipeModuleUntil( const ThisType& u ) : PipeModule<Tout>(u), 
    fn(u.fn), events(u.events), pred(u.pred) { setDependency(); }

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

  Tout compute_local_fn( int fc )
    {
      check();
      if( events->hasValue(fc) ) {
     pred = new Pipe<Tout>( fn( events->getValue(fc), *pred ) );
      }
      Tout v = pred->get_value(fc);
      return v ;
    }
};

template<class Tout, class Tevent>
PipeModuleUntil<Tout,Tevent,Pipe<Tout> (*)(Tevent, const Pipe<Tout>&)>
untilP( const PipeEvents<Tevent>& e, 
     Pipe<Tout> (*fn)(Tevent, const Pipe<Tout>&) ) {
  return PipeModuleUntil<Tout,Tevent,
    Pipe<Tout> (*)(Tevent, const Pipe<Tout>&)>( e, fn );
}
*/

# endif //_PIPEEVENTS_H_

---