Functor.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2004 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Util/units/Functor.h
 
#ifndef __Swinburne_Functor_h
#define __Swinburne_Functor_h
 
#include "Reference.h"
 
// an empty type used to allow one template name
struct __functor_empty {};
 
 
template<typename R, typename A1=__functor_empty, typename A2=__functor_empty>
class Functor;
 
class FunctorBase : public Reference::Able {
public:  
  virtual bool is_valid () const = 0;
 
  virtual bool matches (const FunctorBase* that) const = 0;
};
  
template<typename Function, typename Inherit> 
class FunctorFunction : public Inherit {
public:
      
  bool matches (Function _function) const
  { return function == _function; }
 
  bool is_valid () const { return function != 0; }
 
  virtual bool matches (const FunctorBase* that) const 
  { const FunctorFunction* like = dynamic_cast<const FunctorFunction*> (that);
    return like && like->matches(function); }
 
  protected:
    
  Function function;
    
};
 
template<class Class, typename Method, class Inherit>
class FunctorMethod : public Inherit {
public:
      
  bool matches (const Class* _instance, Method _method) const
  { return (instance && instance == _instance && method == _method); }
    
  bool is_valid () const { return instance && method != 0; }
 
  virtual bool matches (const FunctorBase* that) const 
  { const FunctorMethod* like = dynamic_cast<const FunctorMethod*> (that);
    return like && like->matches(instance,method); }
 
protected:
    
  Reference::To<Class,false> instance;
  
  Method method;
    
};
 
// ///////////////////////////////////////////////////////////////////////////
//
// Generator Functor specialization
//
// ///////////////////////////////////////////////////////////////////////////
 
 
template< typename R, typename A1, typename A2 > 
class Functor< R (), A1, A2 >
{
 public:
 
  typedef R result_type;
 
  //
  // the interface
  //
 
  Functor () { }
 
  R operator() () const { return functor->call(); }
 
  template<class C, typename M> Functor (C* instance, M method)
    { functor = new Method<C, M> (instance, method); }
 
  template<class C, typename M> Functor (const C& instance, M method)
    { functor = new Method<const C, M> (&instance, method); }
 
  template<typename F> Functor (F function)
    { functor = new Function<F> (function); }
 
  template<class C, typename M> void set (C* instance, M method)
    { functor = new Method<C, M> (instance, method); }
 
  template<typename F> void set (F function)
    { functor = new Function<F> (function); }
 
  //
  // the implementation
  //
 
  class Base : public FunctorBase {
  public:  
    virtual R call () const = 0;
  };
  
  template<typename F> class Function : public FunctorFunction<F,Base> {
  public:
      
    Function (F _function)
    { this->function = _function; }
    
    R call () const
    { return R( (*(this->function)) () ); }
    
  };
 
  template<class C, typename M> class Method : public FunctorMethod<C,M,Base> {
  public:
      
    Method (C* _instance, M _method)
    { this->instance = _instance; this->method = _method; }
    
    R call () const
    { return R( (this->instance->*(this->method)) () ); }
      
  };
 
  bool operator ! () const { return !functor; }
    
  operator bool () const { return functor; }
 
  const FunctorBase* get_functor () const { return functor; }
 
 protected: 
  
  Reference::To<Base> functor;
 
};
 
// ///////////////////////////////////////////////////////////////////////////
//
// Unary Functor specialization
//
// ///////////////////////////////////////////////////////////////////////////
 
 
template< typename R, typename A1, typename A2 > 
class Functor< R (A1), A2 >
{
 public:
 
  typedef A1 argument_type;
  typedef R result_type;
 
  //
  // the interface
  //
 
  Functor () { }
 
  R operator() (const A1& p1) const { return functor->call(p1); }
 
  template<class C, typename M> Functor (C* instance, M method)
    { functor = new Method<C, M> (instance, method); }
 
  template<class C, typename M> Functor (const C& instance, M method)
    { functor = new Method<const C, M> (&instance, method); }
 
  template<typename F> Functor (F function)
    { functor = new Function<F> (function); }
 
  template<class C, typename M> void set (C* instance, M method)
    { functor = new Method<C, M> (instance, method); }
 
  template<typename F> void set (F function)
    { functor = new Function<F> (function); }
 
  //
  // the implementation
  //
 
  class Base : public FunctorBase {
  public:  
    virtual R call (const A1& p1) const = 0;
  };
  
  template<typename F> class Function : public FunctorFunction<F,Base> {
  public:
      
    Function (F _function)
    { this->function = _function; }
 
    R call (const A1& p1) const
    { return static_cast<R>( (*(this->function))(p1) ); }
    
  };
 
  template<class C, typename M> class Method : public FunctorMethod<C,M,Base> {
  public:
      
    Method (C* _instance, M _method)
      { this->instance = _instance; this->method = _method; }
    
    R call (const A1& p1) const try
      { return R( (this->instance->*(this->method)) (p1) ); }
    catch (Error& error) { throw error += "Functor<R(T)>::Method::call"; }
    
  };
  
  bool operator ! () const { return !functor; }
    
  operator bool () const { return functor; }
 
  const FunctorBase* get_functor () const { return functor; }
 
 protected: 
  
  Reference::To<Base> functor;
  
};
 
 
// ///////////////////////////////////////////////////////////////////////////
//
// Binary Functor specialization
//
// ///////////////////////////////////////////////////////////////////////////
 
 
template< typename R, typename A1, typename A2 > 
class Functor< R (A1, A2) >
{
 public:
 
  typedef A1 first_argument_type;
  typedef A2 second_argument_type;
  typedef R result_type;
 
  //
  // the interface
  //
 
  Functor () { }
 
  R operator() (const A1& p1, const A2& p2) const 
    { return functor->call(p1,p2); }
  
  template<class C, typename M> Functor (C* instance, M method)
    { functor = new Method<C, M> (instance, method); }
 
  template<class C, typename M> Functor (const C& instance, M method)
    { functor = new Method<const C, M> (&instance, method); }
 
  template<typename F> Functor (F function)
    { functor = new Function<F> (function); }
 
  template<class C, typename M>  void set (C* instance, M method)
    { functor = new Method<C, M> (instance, method); }
 
  template<typename F> void set (F function)
    { functor = new Function<F> (function); }
 
  //
  // the implementation
  //
 
  class Base : public FunctorBase {
  public:  
    virtual R call (const A1& p1, const A2& p2) const = 0;
  };
  
  template<typename F> class Function : public FunctorFunction<F,Base> {
  public:
      
    Function (F _function)
    { this->function = _function; }
    
    R call (const A1& p1, const A2& p2) const
    { return R( (*(this->function)) (p1, p2) ); }
    
  };
 
  template<class C, typename M> class Method : public FunctorMethod<C,M,Base> {
  public:
      
    Method (C* _instance, M _method)
    { this->instance = _instance; this->method = _method; }
    
    R call (const A1& p1, const A2& p2) const
    { return R( (this->instance->*(this->method)) (p1, p2) ); }
    
  };
  
  bool operator ! () const { return !functor; }
    
  operator bool () const { return functor; }
 
  const FunctorBase* get_functor () const { return functor; }
 
 protected: 
  
  Reference::To<Base> functor;
  
};
 
template<typename R, typename A1, typename A2>
bool operator == (const Functor<R,A1,A2>& f1, const Functor<R,A1,A2>& f2)
{
  if (!f1 && !f2)
    return true;
 
  if (!f1 || !f2)
    return false;
 
  if (f1.get_functor() == f2.get_functor())
    return true;
 
  return f1.get_functor()->matches( f2.get_functor() );
 
}
 
#endif