---

/home/slang/XVision2/src/Tools/XVFunctoid.h

# ifndef _XVFUNCTOID_H_
# define _XVFUNCTOID_H_

// Functoid -- abstrction of functional objects

// Abbreviation: F - Function, R - Result, C - Class, An - Argument n

template<class F, class R>
class XVAbsFunctoid {
 public:
  typedef F Function ;
  typedef R Result ;
 protected:
  F f ;
 public:
  explicit XVAbsFunctoid( const F& fn ) : f(fn) {}
  virtual operator bool(void) { return f ; }
};

// Functoids with no argument

template<class F, class R>
class XVFunctoid0 : public XVAbsFunctoid<F,R> {
  typedef XVAbsFunctoid<F,R> Base ;
 public:
  explicit XVFunctoid0( const F& fn ) : Base(fn) {}
  virtual R operator () (void) = 0 ;
};

template<class F, class R>
class XVDirectFun0 : public XVFunctoid0<F,R> {
  typedef XVFunctoid0<F,R> Base ;
 public:
  explicit XVDirectFun0( const F& fn ) : Base(fn) {}
  virtual R operator () (void) { return f() ; }
};

template<class F, class R>
class XVImplicitFun0 : public XVFunctoid0<F,R> {
  typedef XVFunctoid0<F,R> Base ;
 public:
  explicit XVImplicitFun0( const F& fn ) : Base(fn) {}
  virtual R operator () (void) { R r ; f(r) ; return r ; }
};

template<class F, class R>
class XVImpClassFun0 : public XVFunctoid0<F,R> {
  typedef XVFunctoid0<F,R> Base ;
 public:
  explicit XVImpClassFun0( const F& fn ) : Base(fn) {}
  virtual R operator () (void) { R r ; (r.*f)() ; return r ; }
};

template<class F, class R, class C>
class XVClassFun0 : public XVFunctoid0<F,R> {
  typedef XVFunctoid0<F,R> Base ;
 protected:
  C c ;
 public:
  explicit XVClassFun0( const F& fn, const C& host ) : Base(fn), c(host) {}
  virtual R operator () (void) { return (c.*f)() ; }
  C * operator -> (void) { return &c ; }
  const C * operator -> (void) const { return &c ; }
};

template<class F, class R, class C>
class XVClassPtrFun0 : public XVFunctoid0<F,R> {
  typedef XVFunctoid0<F,R> Base ;
 protected:
  C * c ;
 public:
  explicit XVClassPtrFun0( const F& fn, C * host ) : Base(fn), c(host) {}
  virtual R operator () (void) { return (c->*f)() ; }
  C * operator -> (void) { return c ; }
  const C * operator -> (void) const { return c ; }
};

// Functoids with one argument

template<class F, class R, class A1>
class XVFunctoid1 : public XVAbsFunctoid<F,R> {
  typedef XVAbsFunctoid<F,R> Base ;
 public:
  typedef A1 Argument1 ;
 public:
  explicit XVFunctoid1( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1 ) = 0 ;
};

template<class F, class R, class A1>
class XVDirectFun1 : public XVFunctoid1<F,R,A1> {
  typedef XVFunctoid1<F,R,A1> Base ;
 public:
  explicit XVDirectFun1( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1 ) { return f(a1) ; }
};

template<class F, class R, class A1>
class XVImplicitFun1a : public XVFunctoid1<F,R,A1> {
  typedef XVFunctoid1<F,R,A1> Base ;
 public:
  explicit XVImplicitFun1a( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1 ) { R r ; f(r,a1) ; return r ; }
};

template<class F, class R, class A1>
class XVImplicitFun1b : public XVFunctoid1<F,R,A1> {
  typedef XVFunctoid1<F,R,A1> Base ;
 public:
  explicit XVImplicitFun1b( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1 ) { R r ; f(a1,r) ; return r ; }
};

template<class F, class R, class A1>
class XVImpClassFun1 : public XVFunctoid1<F,R,A1> {
  typedef XVFunctoid1<F,R,A1> Base ;
 public:
  explicit XVImpClassFun1( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1 ) { R r ; (r.*f)(a1) ; return r ; }
};

template<class F, class R, class A1>
class XVMemberFun1 : public XVFunctoid1<F,R,A1> {
  typedef XVFunctoid1<F,R,A1> Base ;
 public:
  explicit XVMemberFun1( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1 ) { return (a1.*f)() ; }
};

template<class F, class R, class A1>
class XVDataMemFun : public XVFunctoid1<F,R,A1> {
  typedef XVFunctoid1<F,R,A1> Base ;
 public:
  explicit XVDataMemFun( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1 ) { return a1.*f ; }
};

template<class F, class R, class A1, class C>
class XVClassFun1 : public XVFunctoid1<F,R,A1> {
  typedef XVFunctoid1<F,R,A1> Base ;
 protected:
  C c ;
 public:
  explicit XVClassFun1( const F& fn, const C& host ) : Base(fn), c(host) {}
  virtual R operator () ( const A1& a1 ) { return (c.*f)(a1) ; }
  C * operator -> (void) { return &c ; }
  const C * operator -> (void) const { return &c ; }
};

template<class F, class R, class A1, class C>
class XVClassPtrFun1 : public XVFunctoid1<F,R,A1> {
  typedef XVFunctoid1<F,R,A1> Base ;
 protected:
  C * c ;
 public:
  explicit XVClassPtrFun1( const F& fn, C * host ) : Base(fn), c(host) {}
  virtual R operator () ( const A1& a1 ) { return (c->*f)(a1) ; }
  C * operator -> (void) { return c ; }
  const C * operator -> (void) const { return c ; }
};

// Functoids with two arguments

template<class F, class R, class A1, class A2>
class XVFunctoid2 : public XVAbsFunctoid<F,R> {
  typedef XVAbsFunctoid<F,R> Base ;
 public:
  typedef A1 Argument1 ;
  typedef A2 Argument2 ;
 public:
  explicit XVFunctoid2( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1, const A2& a2 ) = 0 ;
};

template<class F, class R, class A1, class A2>
class XVDirectFun2 : public XVFunctoid2<F,R,A1,A2> {
  typedef XVFunctoid2<F,R,A1,A2> Base ;
 public:
  explicit XVDirectFun2( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1, const A2& a2 ) { return f(a1,a2) ; }
};

template<class F, class R, class A1, class A2>
class XVImplicitFun2a : public XVFunctoid2<F,R,A1,A2> {
  typedef XVFunctoid2<F,R,A1,A2> Base ;
 public:
  explicit XVImplicitFun2a( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1, const A2& a2 ) 
    { R r ; f(r,a1,a2) ; return r ; }
};

template<class F, class R, class A1, class A2>
class XVImplicitFun2b : public XVFunctoid2<F,R,A1,A2> {
  typedef XVFunctoid2<F,R,A1,A2> Base ;
 public:
  explicit XVImplicitFun2b( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1, const A2& a2 ) 
    { R r ; f(a1,a2,r) ; return r ; }
};

template<class F, class R, class A1, class A2>
class XVImpClassFun2 : public XVFunctoid2<F,R,A1,A2> {
  typedef XVFunctoid2<F,R,A1,A2> Base ;
 public:
  explicit XVImpClassFun2( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1, const A2& a2 ) 
    { R r ; (r.*f)(a1,a2) ; return r ; }
};

template<class F, class R, class A1, class A2>
class XVMemberFun2a : public XVFunctoid2<F,R,A1,A2> {
  typedef XVFunctoid2<F,R,A1,A2> Base ;
 public:
  explicit XVMemberFun2a( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1, const A2& a2 ) { return (a1.*f)(a2); }
};

template<class F, class R, class A1, class A2>
class XVMemberFun2b : public XVFunctoid2<F,R,A1,A2> {
  typedef XVFunctoid2<F,R,A1,A2> Base ;
 public:
  explicit XVMemberFun2b( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1, const A2& a2 ) { return (a2.*f)(a1); }
};

template<class F, class R, class A1, class A2, class C>
class XVClassFun2 : public XVFunctoid2<F,R,A1,A2> {
  typedef XVFunctoid2<F,R,A1,A2> Base ;
 protected:
  C c ;
 public:
  explicit XVClassFun2( const F& fn, const C& host ) : Base(fn), c(host) {}
  virtual R operator () ( const A1& a1, const A2& a2 ) 
    { return (c.*f)(a1,a2) ; }
  C * operator -> (void) { return &c ; }
  const C * operator -> (void) const { return &c ; }
};

template<class F, class R, class A1, class A2, class C>
class XVClassPtrFun2 : public XVFunctoid2<F,R,A1,A2> {
  typedef XVFunctoid2<F,R,A1,A2> Base ;
 protected:
  C * c ;
 public:
  explicit XVClassPtrFun2( const F& fn, C * host ) : Base(fn), c(host) {}
  virtual R operator () ( const A1& a1, const A2& a2 ) 
    { return (c->*f)(a1,a2) ; }
  C * operator -> (void) { return c ; }
  const C * operator -> (void) const { return c ; }
};


// Functoids with three arguments

template<class F, class R, class A1, class A2, class A3>
class XVFunctoid3 : public XVAbsFunctoid<F,R> {
  typedef XVAbsFunctoid<F,R> Base ;
 public:
  typedef A1 Argument1 ;
  typedef A2 Argument2 ;
  typedef A3 Argument3 ;
 public:
  explicit XVFunctoid3( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1, const A2& a2, const A3& a3 ) = 0 ;
};

template<class F, class R, class A1, class A2, class A3>
class XVDirectFun3 : public XVFunctoid3<F,R,A1,A2,A3> {
  typedef XVFunctoid3<F,R,A1,A2,A3> Base ;
 public:
  explicit XVDirectFun3( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1, const A2& a2, const A3& a3 ) 
    { return f(a1,a2,a3) ; }
};

template<class F, class R, class A1, class A2, class A3>
class XVImplicitFun3a : public XVFunctoid3<F,R,A1,A2,A3> {
  typedef XVFunctoid3<F,R,A1,A2,A3> Base ;
 public:
  explicit XVImplicitFun3a( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1, const A2& a2, const A3& a3 ) 
    { R r ; f(r,a1,a2,a3) ; return r ; }
};

template<class F, class R, class A1, class A2, class A3>
class XVImplicitFun3b : public XVFunctoid3<F,R,A1,A2,A3> {
  typedef XVFunctoid3<F,R,A1,A2,A3> Base ;
 public:
  explicit XVImplicitFun3b( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1, const A2& a2, const A3& a3 ) 
    { R r ; f(a1,a2,a3,r) ; return r ; }
};

template<class F, class R, class A1, class A2, class A3>
class XVImpClassFun3 : public XVFunctoid3<F,R,A1,A2,A3> {
  typedef XVFunctoid3<F,R,A1,A2,A3> Base ;
 public:
  explicit XVImpClassFun3( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1, const A2& a2, const A3& a3 ) 
    { R r ; (r.*f)(a1,a2,a3) ; return r ; }
};

template<class F, class R, class A1, class A2, class A3>
class XVMemberFun3a : public XVFunctoid3<F,R,A1,A2,A3> {
  typedef XVFunctoid3<F,R,A1,A2,A3> Base ;
 public:
  explicit XVMemberFun3a( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1, const A2& a2, const A3& a3 ) 
    { return (a1.*f)(a2,a3); }
};

template<class F, class R, class A1, class A2, class A3>
class XVMemberFun3b : public XVFunctoid3<F,R,A1,A2,A3> {
  typedef XVFunctoid3<F,R,A1,A2,A3> Base ;
 public:
  explicit XVMemberFun3b( const F& fn ) : Base(fn) {}
  virtual R operator () ( const A1& a1, const A2& a2, const A3& a3 ) 
    { return (a3.*f)(a1,a2); }
};


template<class F, class R, class A1, class A2, class A3,class C>
class XVClassFun3 : public XVFunctoid3<F,R,A1,A2,A3> {
  typedef XVFunctoid3<F,R,A1,A2,A3> Base ;
 protected:
  C c ;
 public:
  explicit XVClassFun3( const F& fn, const C& host ) : Base(fn), c(host) {}
  virtual R operator () ( const A1& a1, const A2& a2, const A3& a3 ) 
    { return (c.*f)(a1,a2,a3) ; }
  C * operator -> (void) { return &c ; }
  const C * operator -> (void) const { return &c ; }
};


template<class F, class R, class A1, class A2, class A3, class C>
class XVClassPtrFun3 : public XVFunctoid3<F,R,A1,A2,A3> {
  typedef XVFunctoid3<F,R,A1,A2,A3> Base ;
 protected:
  C * c ;
 public:
  explicit XVClassPtrFun3( const F& fn, C * host ) : Base(fn), c(host) {}
  virtual R operator () ( const A1& a1, const A2& a2, const A3& a3 ) 
    { return (c->*f)(a1,a2,a3) ; }
  C * operator -> (void) { return c ; }
  const C * operator -> (void) const { return c ; }
};

// Functoid Operations

template<class F1, class F2, class R, class A1>
class XVComposeFun1 : public XVFunctoid1<F1,R,A1> {
  typedef XVFunctoid1<F1,R,A1> Base ;
 protected:
  F2 g ;
 public:
  explicit XVComposeFun1( const F1& fn, const F2& gn ) : Base(fn), g(gn) {}
  virtual R operator () ( const A1& a1 ) { return f(g(a1)); }
};

# endif //_XVFUNCTOID_H_

---