include/ermyth/callback.h

#ifndef ERMYTH_FUNCTOR_H
#define ERMYTH_FUNCTOR_H

#include <memory>
#include <iostream>
#include <vector>

#ifndef BENCHMARK
#define BENCHMARK 0
#endif
#ifndef TIMER
#define TIMER 0
#endif
#ifndef TEST_FUNCTOR
#define TEST_FUNCTOR 0
#endif
#ifndef TEST_CALLBACKS
#define TEST_CALLBACKS 0
#endif

#if __GNUC__ < 4
#define GCC_BUG_8271
#endif

namespace functor
{
  namespace impl
  {
    class GenericClass;

    template<class OutputClass, class InputClass>
    OutputClass union_cast (const InputClass input)
    {
      union
      {
        OutputClass out;
        InputClass in;
      } u;
      u.in = input;
      return u.out;
    }

    class storage
    {
    protected:
      typedef void (impl::GenericClass::*GenericMemFuncType) ();
      impl::GenericClass *m_pthis;
      GenericMemFuncType m_pFunction;

    public:
      storage ()
      : m_pthis (0), m_pFunction (0)
      {
      }

      void clear ()
      {
        m_pthis = 0;
        m_pFunction = 0;
      }

    public:
      bool operator == (const storage &x) const
      {
        return m_pthis == x.m_pthis && m_pFunction == x.m_pFunction;
      }

      bool operator != (const storage &x) const
      {
        return !(*this == x);
      }

      bool operator ! () const
      {
        return m_pthis == 0 && m_pFunction == 0;
      }

    public:
      storage &operator = (const storage &rhs)
      {
        store (rhs);
        return *this;
      }

      bool operator < (const storage &rhs) const
      {
        if (m_pthis != rhs.m_pthis)
          return m_pthis < rhs.m_pthis;
        return memcmp (&m_pFunction, &rhs.m_pFunction, sizeof (m_pFunction)) < 0;
      }

      bool operator > (const storage &rhs) const
      {
        return rhs.operator < (*this);
      }

      storage (const storage &rhs)
      : m_pthis (rhs.m_pthis), m_pFunction (rhs.m_pFunction)
      {
      }

    protected:
      void store (const storage &rhs)
      {
        m_pFunction = rhs.m_pFunction;
        m_pthis = rhs.m_pthis;
      }
    };

    template<class GenericMemFunc, class StaticFuncPtr>
    class ClosurePtr : public storage
    {
      typedef ClosurePtr<GenericMemFunc, StaticFuncPtr> self_type;

    public:
      template<class X, class XMemFunc>
      void bindmemfunc (X *pthis, XMemFunc function_to_bind)
      {
        m_pFunction = reinterpret_cast<GenericMemFuncType> (function_to_bind);
        m_pthis = reinterpret_cast<GenericClass *> (pthis);
      }

      template<class X, class XMemFunc>
      void bindconstmemfunc (const X *pthis, XMemFunc function_to_bind)
      {
        m_pFunction = reinterpret_cast<GenericMemFuncType> (function_to_bind);
        m_pthis = reinterpret_cast<GenericClass *> (const_cast<X *> (pthis));
      }

#ifdef GCC_BUG_8271
      template<class X, class XMemFunc>
      void bindmemfunc (const X *pthis, XMemFunc function_to_bind)
      {
        bindconstmemfunc (pthis, function_to_bind);
      }
#endif

      GenericClass *GetClosureThis () const
      {
        return m_pthis;
      }

      GenericMemFunc GetClosureMemPtr () const
      {
        return reinterpret_cast<GenericMemFunc> (m_pFunction);
      }

      template<class DerivedClass, class ParentInvokerSig>
      void bindstaticfunc (DerivedClass *pParent, ParentInvokerSig static_function_invoker, StaticFuncPtr function_to_bind)
      {
        if (function_to_bind == 0)
          m_pFunction = 0;
        else
          bindmemfunc (pParent, static_function_invoker);

        m_pthis = reinterpret_cast<GenericClass *> (reinterpret_cast<long> (function_to_bind));
      }

      operator StaticFuncPtr () const
      {
        return union_cast<StaticFuncPtr> (this);
      }

      bool operator == (StaticFuncPtr funcptr) const
      {
        if (funcptr == 0)
          return !*this;
        else
          return funcptr == static_cast<StaticFuncPtr> (this);
      }

      bool operator != (StaticFuncPtr funcptr) const
      {
        return !(*this == funcptr);
      }

      bool operator == (self_type const &rhs) const
      {
        return this->storage::operator == (rhs);
      }

      bool operator != (self_type const &rhs) const
      {
        return !(*this == rhs);
      }
    };
  }

  // Auto-generated code for  Functors {{{
  // n = 0

  template<class RetType = void>
  class functor0
  {
  private:
    typedef RetType (*StaticFunctionPtr) ();
    typedef RetType (impl::GenericClass::*GenericMemFn) ();
    typedef impl::ClosurePtr<GenericMemFn, StaticFunctionPtr> ClosureType;
    ClosureType m_Closure;

  public:
    typedef functor0 type;

    functor0 ()
    {
      clear ();
    }

    functor0 (const functor0 &x)
    {
      m_Closure = x.m_Closure;
    }

    void operator = (const functor0 &x)
    {
      m_Closure = x.m_Closure;
    }

    bool operator == (const functor0 &x) const
    {
      return m_Closure == x.m_Closure;
    }

    bool operator != (const functor0 &x) const
    {
      return m_Closure != x.m_Closure;
    }

    bool operator < (const functor0 &x) const
    {
      return m_Closure < x.m_Closure;
    }

    bool operator > (const functor0 &x) const
    {
      return m_Closure > x.m_Closure;
    }

    template<class X, class Y>
    functor0 (Y *pthis, RetType (X::*function_to_bind) ())
    {
      m_Closure.bindmemfunc (static_cast<X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    void bind (Y *pthis, RetType (X::*function_to_bind) ())
    {
      m_Closure.bindmemfunc (static_cast<X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    functor0 (const Y *pthis, RetType (X::*function_to_bind) () const)
    {
      m_Closure.bindconstmemfunc (static_cast<const X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    void bind (const Y *pthis, RetType (X::*function_to_bind) () const)
    {
      m_Closure.bindconstmemfunc (static_cast<const X *> (pthis), function_to_bind);
    }

    functor0 (RetType (*function_to_bind) ())
    {
      bind (function_to_bind);
    }

    void operator = (RetType (*function_to_bind) ())
    {
      bind (function_to_bind);
    }

    void bind (RetType (*function_to_bind) ())
    {
      m_Closure.bindstaticfunc (this, &functor0::InvokeStaticFunction, function_to_bind);
    }

    RetType operator () () const
    {
      return (m_Closure.GetClosureThis ()->*(m_Closure.GetClosureMemPtr ())) ();
    }

  public:
    bool operator == (StaticFunctionPtr funcptr) const
    {
      return m_Closure == funcptr;
    }

    bool operator != (StaticFunctionPtr funcptr) const
    {
      return m_Closure != funcptr;
    }

    bool operator ! () const
    {
      return !m_Closure;
    }

    void clear ()
    {
      m_Closure.clear ();
    }

    const impl::storage &retrieve () const
    {
      return m_Closure;
    }

    void store (const impl::storage &any)
    {
      m_Closure = any;
    }

  private:
    RetType InvokeStaticFunction () const
    {
      return (*(static_cast<StaticFunctionPtr> (m_Closure))) ();
    }
  };

  // n = 1

  template<class Param1, class RetType = void>
  class functor1
  {
  private:
    typedef RetType (*StaticFunctionPtr) (Param1 p1);
    typedef RetType (impl::GenericClass::*GenericMemFn) (Param1 p1);
    typedef impl::ClosurePtr<GenericMemFn, StaticFunctionPtr> ClosureType;
    ClosureType m_Closure;

  public:
    typedef functor1 type;

    functor1 ()
    {
      clear ();
    }

    functor1 (const functor1 &x)
    {
      m_Closure = x.m_Closure;
    }

    void operator = (const functor1 &x)
    {
      m_Closure = x.m_Closure;
    }

    bool operator == (const functor1 &x) const
    {
      return m_Closure == x.m_Closure;
    }

    bool operator != (const functor1 &x) const
    {
      return m_Closure != x.m_Closure;
    }

    bool operator < (const functor1 &x) const
    {
      return m_Closure < x.m_Closure;
    }

    bool operator > (const functor1 &x) const
    {
      return m_Closure > x.m_Closure;
    }

    template<class X, class Y>
    functor1 (Y *pthis, RetType (X::*function_to_bind) (Param1 p1))
    {
      m_Closure.bindmemfunc (static_cast<X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    void bind (Y *pthis, RetType (X::*function_to_bind) (Param1 p1))
    {
      m_Closure.bindmemfunc (static_cast<X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    functor1 (const Y *pthis, RetType (X::*function_to_bind) (Param1 p1) const)
    {
      m_Closure.bindconstmemfunc (static_cast<const X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    void bind (const Y *pthis, RetType (X::*function_to_bind) (Param1 p1) const)
    {
      m_Closure.bindconstmemfunc (static_cast<const X *> (pthis), function_to_bind);
    }

    functor1 (RetType (*function_to_bind) (Param1 p1))
    {
      bind (function_to_bind);
    }

    void operator = (RetType (*function_to_bind) (Param1 p1))
    {
      bind (function_to_bind);
    }

    void bind (RetType (*function_to_bind) (Param1 p1))
    {
      m_Closure.bindstaticfunc (this, &functor1::InvokeStaticFunction, function_to_bind);
    }

    RetType operator () (Param1 p1) const
    {
      return (m_Closure.GetClosureThis ()->*(m_Closure.GetClosureMemPtr ())) (p1);
    }

  public:
    bool operator == (StaticFunctionPtr funcptr) const
    {
      return m_Closure == funcptr;
    }

    bool operator != (StaticFunctionPtr funcptr) const
    {
      return m_Closure != funcptr;
    }

    bool operator ! () const
    {
      return !m_Closure;
    }

    void clear ()
    {
      m_Closure.clear ();
    }

    const impl::storage &retrieve () const
    {
      return m_Closure;
    }

    void store (const impl::storage &any)
    {
      m_Closure = any;
    }

  private:
    RetType InvokeStaticFunction (Param1 p1) const
    {
      return (*(static_cast<StaticFunctionPtr> (m_Closure))) (p1);
    }
  };

  // n = 2

  template<class Param1, class Param2, class RetType = void>
  class functor2
  {
  private:
    typedef RetType (*StaticFunctionPtr) (Param1 p1, Param2 p2);
    typedef RetType (impl::GenericClass::*GenericMemFn) (Param1 p1, Param2 p2);
    typedef impl::ClosurePtr<GenericMemFn, StaticFunctionPtr> ClosureType;
    ClosureType m_Closure;

  public:
    typedef functor2 type;

    functor2 ()
    {
      clear ();
    }

    functor2 (const functor2 &x)
    {
      m_Closure = x.m_Closure;
    }

    void operator = (const functor2 &x)
    {
      m_Closure = x.m_Closure;
    }

    bool operator == (const functor2 &x) const
    {
      return m_Closure == x.m_Closure;
    }

    bool operator != (const functor2 &x) const
    {
      return m_Closure != x.m_Closure;
    }

    bool operator < (const functor2 &x) const
    {
      return m_Closure < x.m_Closure;
    }

    bool operator > (const functor2 &x) const
    {
      return m_Closure > x.m_Closure;
    }

    template<class X, class Y>
    functor2 (Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2))
    {
      m_Closure.bindmemfunc (static_cast<X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    void bind (Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2))
    {
      m_Closure.bindmemfunc (static_cast<X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    functor2 (const Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2) const)
    {
      m_Closure.bindconstmemfunc (static_cast<const X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    void bind (const Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2) const)
    {
      m_Closure.bindconstmemfunc (static_cast<const X *> (pthis), function_to_bind);
    }

    functor2 (RetType (*function_to_bind) (Param1 p1, Param2 p2))
    {
      bind (function_to_bind);
    }

    void operator = (RetType (*function_to_bind) (Param1 p1, Param2 p2))
    {
      bind (function_to_bind);
    }

    void bind (RetType (*function_to_bind) (Param1 p1, Param2 p2))
    {
      m_Closure.bindstaticfunc (this, &functor2::InvokeStaticFunction, function_to_bind);
    }

    RetType operator () (Param1 p1, Param2 p2) const
    {
      return (m_Closure.GetClosureThis ()->*(m_Closure.GetClosureMemPtr ())) (p1, p2);
    }

  public:
    bool operator == (StaticFunctionPtr funcptr) const
    {
      return m_Closure == funcptr;
    }

    bool operator != (StaticFunctionPtr funcptr) const
    {
      return m_Closure != funcptr;
    }

    bool operator ! () const
    {
      return !m_Closure;
    }

    void clear ()
    {
      m_Closure.clear ();
    }

    const impl::storage &retrieve () const
    {
      return m_Closure;
    }

    void store (const impl::storage &any)
    {
      m_Closure = any;
    }

  private:
    RetType InvokeStaticFunction (Param1 p1, Param2 p2) const
    {
      return (*(static_cast<StaticFunctionPtr> (m_Closure))) (p1, p2);
    }
  };

  // n = 3

  template<class Param1, class Param2, class Param3, class RetType = void>
  class functor3
  {
  private:
    typedef RetType (*StaticFunctionPtr) (Param1 p1, Param2 p2, Param3 p3);
    typedef RetType (impl::GenericClass::*GenericMemFn) (Param1 p1, Param2 p2, Param3 p3);
    typedef impl::ClosurePtr<GenericMemFn, StaticFunctionPtr> ClosureType;
    ClosureType m_Closure;

  public:
    typedef functor3 type;

    functor3 ()
    {
      clear ();
    }

    functor3 (const functor3 &x)
    {
      m_Closure = x.m_Closure;
    }

    void operator = (const functor3 &x)
    {
      m_Closure = x.m_Closure;
    }

    bool operator == (const functor3 &x) const
    {
      return m_Closure == x.m_Closure;
    }

    bool operator != (const functor3 &x) const
    {
      return m_Closure != x.m_Closure;
    }

    bool operator < (const functor3 &x) const
    {
      return m_Closure < x.m_Closure;
    }

    bool operator > (const functor3 &x) const
    {
      return m_Closure > x.m_Closure;
    }

    template<class X, class Y>
    functor3 (Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3))
    {
      m_Closure.bindmemfunc (static_cast<X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    void bind (Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3))
    {
      m_Closure.bindmemfunc (static_cast<X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    functor3 (const Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3) const)
    {
      m_Closure.bindconstmemfunc (static_cast<const X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    void bind (const Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3) const)
    {
      m_Closure.bindconstmemfunc (static_cast<const X *> (pthis), function_to_bind);
    }

    functor3 (RetType (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3))
    {
      bind (function_to_bind);
    }

    void operator = (RetType (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3))
    {
      bind (function_to_bind);
    }

    void bind (RetType (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3))
    {
      m_Closure.bindstaticfunc (this, &functor3::InvokeStaticFunction, function_to_bind);
    }

    RetType operator () (Param1 p1, Param2 p2, Param3 p3) const
    {
      return (m_Closure.GetClosureThis ()->*(m_Closure.GetClosureMemPtr ())) (p1, p2, p3);
    }

  public:
    bool operator == (StaticFunctionPtr funcptr) const
    {
      return m_Closure == funcptr;
    }

    bool operator != (StaticFunctionPtr funcptr) const
    {
      return m_Closure != funcptr;
    }

    bool operator ! () const
    {
      return !m_Closure;
    }

    void clear ()
    {
      m_Closure.clear ();
    }

    const impl::storage &retrieve () const
    {
      return m_Closure;
    }

    void store (const impl::storage &any)
    {
      m_Closure = any;
    }

  private:
    RetType InvokeStaticFunction (Param1 p1, Param2 p2, Param3 p3) const
    {
      return (*(static_cast<StaticFunctionPtr> (m_Closure))) (p1, p2, p3);
    }
  };

  // n = 4

  template<class Param1, class Param2, class Param3, class Param4, class RetType = void>
  class functor4
  {
  private:
    typedef RetType (*StaticFunctionPtr) (Param1 p1, Param2 p2, Param3 p3, Param4 p4);
    typedef RetType (impl::GenericClass::*GenericMemFn) (Param1 p1, Param2 p2, Param3 p3, Param4 p4);
    typedef impl::ClosurePtr<GenericMemFn, StaticFunctionPtr> ClosureType;
    ClosureType m_Closure;

  public:
    typedef functor4 type;

    functor4 ()
    {
      clear ();
    }

    functor4 (const functor4 &x)
    {
      m_Closure = x.m_Closure;
    }

    void operator = (const functor4 &x)
    {
      m_Closure = x.m_Closure;
    }

    bool operator == (const functor4 &x) const
    {
      return m_Closure == x.m_Closure;
    }

    bool operator != (const functor4 &x) const
    {
      return m_Closure != x.m_Closure;
    }

    bool operator < (const functor4 &x) const
    {
      return m_Closure < x.m_Closure;
    }

    bool operator > (const functor4 &x) const
    {
      return m_Closure > x.m_Closure;
    }

    template<class X, class Y>
    functor4 (Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4))
    {
      m_Closure.bindmemfunc (static_cast<X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    void bind (Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4))
    {
      m_Closure.bindmemfunc (static_cast<X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    functor4 (const Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4) const)
    {
      m_Closure.bindconstmemfunc (static_cast<const X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    void bind (const Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4) const)
    {
      m_Closure.bindconstmemfunc (static_cast<const X *> (pthis), function_to_bind);
    }

    functor4 (RetType (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4))
    {
      bind (function_to_bind);
    }

    void operator = (RetType (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4))
    {
      bind (function_to_bind);
    }

    void bind (RetType (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4))
    {
      m_Closure.bindstaticfunc (this, &functor4::InvokeStaticFunction, function_to_bind);
    }

    RetType operator () (Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
    {
      return (m_Closure.GetClosureThis ()->*(m_Closure.GetClosureMemPtr ())) (p1, p2, p3, p4);
    }

  public:
    bool operator == (StaticFunctionPtr funcptr) const
    {
      return m_Closure == funcptr;
    }

    bool operator != (StaticFunctionPtr funcptr) const
    {
      return m_Closure != funcptr;
    }

    bool operator ! () const
    {
      return !m_Closure;
    }

    void clear ()
    {
      m_Closure.clear ();
    }

    const impl::storage &retrieve () const
    {
      return m_Closure;
    }

    void store (const impl::storage &any)
    {
      m_Closure = any;
    }

  private:
    RetType InvokeStaticFunction (Param1 p1, Param2 p2, Param3 p3, Param4 p4) const
    {
      return (*(static_cast<StaticFunctionPtr> (m_Closure))) (p1, p2, p3, p4);
    }
  };

  // n = 5

  template<class Param1, class Param2, class Param3, class Param4, class Param5, class RetType = void>
  class functor5
  {
  private:
    typedef RetType (*StaticFunctionPtr) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5);
    typedef RetType (impl::GenericClass::*GenericMemFn) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5);
    typedef impl::ClosurePtr<GenericMemFn, StaticFunctionPtr> ClosureType;
    ClosureType m_Closure;

  public:
    typedef functor5 type;

    functor5 ()
    {
      clear ();
    }

    functor5 (const functor5 &x)
    {
      m_Closure = x.m_Closure;
    }

    void operator = (const functor5 &x)
    {
      m_Closure = x.m_Closure;
    }

    bool operator == (const functor5 &x) const
    {
      return m_Closure == x.m_Closure;
    }

    bool operator != (const functor5 &x) const
    {
      return m_Closure != x.m_Closure;
    }

    bool operator < (const functor5 &x) const
    {
      return m_Closure < x.m_Closure;
    }

    bool operator > (const functor5 &x) const
    {
      return m_Closure > x.m_Closure;
    }

    template<class X, class Y>
    functor5 (Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5))
    {
      m_Closure.bindmemfunc (static_cast<X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    void bind (Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5))
    {
      m_Closure.bindmemfunc (static_cast<X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    functor5 (const Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const)
    {
      m_Closure.bindconstmemfunc (static_cast<const X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    void bind (const Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const)
    {
      m_Closure.bindconstmemfunc (static_cast<const X *> (pthis), function_to_bind);
    }

    functor5 (RetType (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5))
    {
      bind (function_to_bind);
    }

    void operator = (RetType (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5))
    {
      bind (function_to_bind);
    }

    void bind (RetType (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5))
    {
      m_Closure.bindstaticfunc (this, &functor5::InvokeStaticFunction, function_to_bind);
    }

    RetType operator () (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
    {
      return (m_Closure.GetClosureThis ()->*(m_Closure.GetClosureMemPtr ())) (p1, p2, p3, p4, p5);
    }

  public:
    bool operator == (StaticFunctionPtr funcptr) const
    {
      return m_Closure == funcptr;
    }

    bool operator != (StaticFunctionPtr funcptr) const
    {
      return m_Closure != funcptr;
    }

    bool operator ! () const
    {
      return !m_Closure;
    }

    void clear ()
    {
      m_Closure.clear ();
    }

    const impl::storage &retrieve () const
    {
      return m_Closure;
    }

    void store (const impl::storage &any)
    {
      m_Closure = any;
    }

  private:
    RetType InvokeStaticFunction (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const
    {
      return (*(static_cast<StaticFunctionPtr> (m_Closure))) (p1, p2, p3, p4, p5);
    }
  };

  // n = 6

  template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class RetType = void>
  class functor6
  {
  private:
    typedef RetType (*StaticFunctionPtr) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6);
    typedef RetType (impl::GenericClass::*GenericMemFn) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6);
    typedef impl::ClosurePtr<GenericMemFn, StaticFunctionPtr> ClosureType;
    ClosureType m_Closure;

  public:
    typedef functor6 type;

    functor6 ()
    {
      clear ();
    }

    functor6 (const functor6 &x)
    {
      m_Closure = x.m_Closure;
    }

    void operator = (const functor6 &x)
    {
      m_Closure = x.m_Closure;
    }

    bool operator == (const functor6 &x) const
    {
      return m_Closure == x.m_Closure;
    }

    bool operator != (const functor6 &x) const
    {
      return m_Closure != x.m_Closure;
    }

    bool operator < (const functor6 &x) const
    {
      return m_Closure < x.m_Closure;
    }

    bool operator > (const functor6 &x) const
    {
      return m_Closure > x.m_Closure;
    }

    template<class X, class Y>
    functor6 (Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6))
    {
      m_Closure.bindmemfunc (static_cast<X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    void bind (Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6))
    {
      m_Closure.bindmemfunc (static_cast<X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    functor6 (const Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const)
    {
      m_Closure.bindconstmemfunc (static_cast<const X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    void bind (const Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const)
    {
      m_Closure.bindconstmemfunc (static_cast<const X *> (pthis), function_to_bind);
    }

    functor6 (RetType (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6))
    {
      bind (function_to_bind);
    }

    void operator = (RetType (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6))
    {
      bind (function_to_bind);
    }

    void bind (RetType (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6))
    {
      m_Closure.bindstaticfunc (this, &functor6::InvokeStaticFunction, function_to_bind);
    }

    RetType operator () (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
    {
      return (m_Closure.GetClosureThis ()->*(m_Closure.GetClosureMemPtr ())) (p1, p2, p3, p4, p5, p6);
    }

  public:
    bool operator == (StaticFunctionPtr funcptr) const
    {
      return m_Closure == funcptr;
    }

    bool operator != (StaticFunctionPtr funcptr) const
    {
      return m_Closure != funcptr;
    }

    bool operator ! () const
    {
      return !m_Closure;
    }

    void clear ()
    {
      m_Closure.clear ();
    }

    const impl::storage &retrieve () const
    {
      return m_Closure;
    }

    void store (const impl::storage &any)
    {
      m_Closure = any;
    }

  private:
    RetType InvokeStaticFunction (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const
    {
      return (*(static_cast<StaticFunctionPtr> (m_Closure))) (p1, p2, p3, p4, p5, p6);
    }
  };

  // n = 7

  template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class RetType = void>
  class functor7
  {
  private:
    typedef RetType (*StaticFunctionPtr) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7);
    typedef RetType (impl::GenericClass::*GenericMemFn) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7);
    typedef impl::ClosurePtr<GenericMemFn, StaticFunctionPtr> ClosureType;
    ClosureType m_Closure;

  public:
    typedef functor7 type;

    functor7 ()
    {
      clear ();
    }

    functor7 (const functor7 &x)
    {
      m_Closure = x.m_Closure;
    }

    void operator = (const functor7 &x)
    {
      m_Closure = x.m_Closure;
    }

    bool operator == (const functor7 &x) const
    {
      return m_Closure == x.m_Closure;
    }

    bool operator != (const functor7 &x) const
    {
      return m_Closure != x.m_Closure;
    }

    bool operator < (const functor7 &x) const
    {
      return m_Closure < x.m_Closure;
    }

    bool operator > (const functor7 &x) const
    {
      return m_Closure > x.m_Closure;
    }

    template<class X, class Y>
    functor7 (Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7))
    {
      m_Closure.bindmemfunc (static_cast<X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    void bind (Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7))
    {
      m_Closure.bindmemfunc (static_cast<X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    functor7 (const Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const)
    {
      m_Closure.bindconstmemfunc (static_cast<const X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    void bind (const Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const)
    {
      m_Closure.bindconstmemfunc (static_cast<const X *> (pthis), function_to_bind);
    }

    functor7 (RetType (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7))
    {
      bind (function_to_bind);
    }

    void operator = (RetType (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7))
    {
      bind (function_to_bind);
    }

    void bind (RetType (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7))
    {
      m_Closure.bindstaticfunc (this, &functor7::InvokeStaticFunction, function_to_bind);
    }

    RetType operator () (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
    {
      return (m_Closure.GetClosureThis ()->*(m_Closure.GetClosureMemPtr ())) (p1, p2, p3, p4, p5, p6, p7);
    }

  public:
    bool operator == (StaticFunctionPtr funcptr) const
    {
      return m_Closure == funcptr;
    }

    bool operator != (StaticFunctionPtr funcptr) const
    {
      return m_Closure != funcptr;
    }

    bool operator ! () const
    {
      return !m_Closure;
    }

    void clear ()
    {
      m_Closure.clear ();
    }

    const impl::storage &retrieve () const
    {
      return m_Closure;
    }

    void store (const impl::storage &any)
    {
      m_Closure = any;
    }

  private:
    RetType InvokeStaticFunction (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const
    {
      return (*(static_cast<StaticFunctionPtr> (m_Closure))) (p1, p2, p3, p4, p5, p6, p7);
    }
  };

  // n = 8

  template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType = void>
  class functor8
  {
  private:
    typedef RetType (*StaticFunctionPtr) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8);
    typedef RetType (impl::GenericClass::*GenericMemFn) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8);
    typedef impl::ClosurePtr<GenericMemFn, StaticFunctionPtr> ClosureType;
    ClosureType m_Closure;

  public:
    typedef functor8 type;

    functor8 ()
    {
      clear ();
    }

    functor8 (const functor8 &x)
    {
      m_Closure = x.m_Closure;
    }

    void operator = (const functor8 &x)
    {
      m_Closure = x.m_Closure;
    }

    bool operator == (const functor8 &x) const
    {
      return m_Closure == x.m_Closure;
    }

    bool operator != (const functor8 &x) const
    {
      return m_Closure != x.m_Closure;
    }

    bool operator < (const functor8 &x) const
    {
      return m_Closure < x.m_Closure;
    }

    bool operator > (const functor8 &x) const
    {
      return m_Closure > x.m_Closure;
    }

    template<class X, class Y>
    functor8 (Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8))
    {
      m_Closure.bindmemfunc (static_cast<X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    void bind (Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8))
    {
      m_Closure.bindmemfunc (static_cast<X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    functor8 (const Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const)
    {
      m_Closure.bindconstmemfunc (static_cast<const X*> (pthis), function_to_bind);
    }

    template<class X, class Y>
    void bind (const Y *pthis, RetType (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const)
    {
      m_Closure.bindconstmemfunc (static_cast<const X *> (pthis), function_to_bind);
    }

    functor8 (RetType (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8))
    {
      bind (function_to_bind);
    }

    void operator = (RetType (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8))
    {
      bind (function_to_bind);
    }

    void bind (RetType (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8))
    {
      m_Closure.bindstaticfunc (this, &functor8::InvokeStaticFunction, function_to_bind);
    }

    RetType operator () (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const
    {
      return (m_Closure.GetClosureThis ()->*(m_Closure.GetClosureMemPtr ())) (p1, p2, p3, p4, p5, p6, p7, p8);
    }

  public:
    bool operator == (StaticFunctionPtr funcptr) const
    {
      return m_Closure == funcptr;
    }

    bool operator != (StaticFunctionPtr funcptr) const
    {
      return m_Closure != funcptr;
    }

    bool operator ! () const
    {
      return !m_Closure;
    }

    void clear ()
    {
      m_Closure.clear ();
    }

    const impl::storage &retrieve () const
    {
      return m_Closure;
    }

    void store (const impl::storage &any)
    {
      m_Closure = any;
    }

  private:
    RetType InvokeStaticFunction (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const
    {
      return (*(static_cast<StaticFunctionPtr> (m_Closure))) (p1, p2, p3, p4, p5, p6, p7, p8);
    }
  };

  // }}} End auto-generated code

  template<typename Signature>
  class functor;

  // Auto-generated code for  Functors with functioncall syntax {{{
  // n = 0

  template<typename R>
  class functor<R ()>
  : public functor0<R>
  {
  public:
    typedef functor0<R> BaseType;

    typedef functor SelfType;

    functor ()
    : BaseType ()
    {
    }

    template<class X, class Y>
    functor (Y *pthis, R (X::*function_to_bind) ())
    : BaseType (pthis, function_to_bind)
    {
    }

    template<class X, class Y>
    functor (const Y *pthis, R (X::*function_to_bind) () const)
    : BaseType (pthis, function_to_bind)
    {
    }

    functor (R (*function_to_bind) ())
    : BaseType (function_to_bind)
    {
    }

    void operator = (const BaseType &x)
    {
      *static_cast<BaseType*> (this) = x;
    }
  };

  // n = 1

  template<typename R, class Param1>
  class functor<R (Param1)>
  : public functor1<Param1, R>
  {
  public:
    typedef functor1<Param1, R> BaseType;

    typedef functor SelfType;

    functor ()
    : BaseType ()
    {
    }

    template<class X, class Y>
    functor (Y *pthis, R (X::*function_to_bind) (Param1 p1))
    : BaseType (pthis, function_to_bind)
    {
    }

    template<class X, class Y>
    functor (const Y *pthis, R (X::*function_to_bind) (Param1 p1) const)
    : BaseType (pthis, function_to_bind)
    {
    }

    functor (R (*function_to_bind) (Param1 p1))
    : BaseType (function_to_bind)
    {
    }

    void operator = (const BaseType &x)
    {
      *static_cast<BaseType*> (this) = x;
    }
  };

  // n = 2

  template<typename R, class Param1, class Param2>
  class functor<R (Param1, Param2)>
  : public functor2<Param1, Param2, R>
  {
  public:
    typedef functor2<Param1, Param2, R> BaseType;

    typedef functor SelfType;

    functor ()
    : BaseType ()
    {
    }

    template<class X, class Y>
    functor (Y *pthis, R (X::*function_to_bind) (Param1 p1, Param2 p2))
    : BaseType (pthis, function_to_bind)
    {
    }

    template<class X, class Y>
    functor (const Y *pthis, R (X::*function_to_bind) (Param1 p1, Param2 p2) const)
    : BaseType (pthis, function_to_bind)
    {
    }

    functor (R (*function_to_bind) (Param1 p1, Param2 p2))
    : BaseType (function_to_bind)
    {
    }

    void operator = (const BaseType &x)
    {
      *static_cast<BaseType*> (this) = x;
    }
  };

  // n = 3

  template<typename R, class Param1, class Param2, class Param3>
  class functor<R (Param1, Param2, Param3)>
  : public functor3<Param1, Param2, Param3, R>
  {
  public:
    typedef functor3<Param1, Param2, Param3, R> BaseType;

    typedef functor SelfType;

    functor ()
    : BaseType ()
    {
    }

    template<class X, class Y>
    functor (Y *pthis, R (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3))
    : BaseType (pthis, function_to_bind)
    {
    }

    template<class X, class Y>
    functor (const Y *pthis, R (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3) const)
    : BaseType (pthis, function_to_bind)
    {
    }

    functor (R (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3))
    : BaseType (function_to_bind)
    {
    }

    void operator = (const BaseType &x)
    {
      *static_cast<BaseType*> (this) = x;
    }
  };

  // n = 4

  template<typename R, class Param1, class Param2, class Param3, class Param4>
  class functor<R (Param1, Param2, Param3, Param4)>
  : public functor4<Param1, Param2, Param3, Param4, R>
  {
  public:
    typedef functor4<Param1, Param2, Param3, Param4, R> BaseType;

    typedef functor SelfType;

    functor ()
    : BaseType ()
    {
    }

    template<class X, class Y>
    functor (Y *pthis, R (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4))
    : BaseType (pthis, function_to_bind)
    {
    }

    template<class X, class Y>
    functor (const Y *pthis, R (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4) const)
    : BaseType (pthis, function_to_bind)
    {
    }

    functor (R (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4))
    : BaseType (function_to_bind)
    {
    }

    void operator = (const BaseType &x)
    {
      *static_cast<BaseType*> (this) = x;
    }
  };

  // n = 5

  template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5>
  class functor<R (Param1, Param2, Param3, Param4, Param5)>
  : public functor5<Param1, Param2, Param3, Param4, Param5, R>
  {
  public:
    typedef functor5<Param1, Param2, Param3, Param4, Param5, R> BaseType;

    typedef functor SelfType;

    functor ()
    : BaseType ()
    {
    }

    template<class X, class Y>
    functor (Y *pthis, R (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5))
    : BaseType (pthis, function_to_bind)
    {
    }

    template<class X, class Y>
    functor (const Y *pthis, R (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const)
    : BaseType (pthis, function_to_bind)
    {
    }

    functor (R (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5))
    : BaseType (function_to_bind)
    {
    }

    void operator = (const BaseType &x)
    {
      *static_cast<BaseType*> (this) = x;
    }
  };

  // n = 6

  template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
  class functor<R (Param1, Param2, Param3, Param4, Param5, Param6)>
  : public functor6<Param1, Param2, Param3, Param4, Param5, Param6, R>
  {
  public:
    typedef functor6<Param1, Param2, Param3, Param4, Param5, Param6, R> BaseType;

    typedef functor SelfType;

    functor ()
    : BaseType ()
    {
    }

    template<class X, class Y>
    functor (Y *pthis, R (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6))
    : BaseType (pthis, function_to_bind)
    {
    }

    template<class X, class Y>
    functor (const Y *pthis, R (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const)
    : BaseType (pthis, function_to_bind)
    {
    }

    functor (R (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6))
    : BaseType (function_to_bind)
    {
    }

    void operator = (const BaseType &x)
    {
      *static_cast<BaseType*> (this) = x;
    }
  };

  // n = 7

  template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
  class functor<R (Param1, Param2, Param3, Param4, Param5, Param6, Param7)>
  : public functor7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, R>
  {
  public:
    typedef functor7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, R> BaseType;

    typedef functor SelfType;

    functor ()
    : BaseType ()
    {
    }

    template<class X, class Y>
    functor (Y *pthis, R (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7))
    : BaseType (pthis, function_to_bind)
    {
    }

    template<class X, class Y>
    functor (const Y *pthis, R (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const)
    : BaseType (pthis, function_to_bind)
    {
    }

    functor (R (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7))
    : BaseType (function_to_bind)
    {
    }

    void operator = (const BaseType &x)
    {
      *static_cast<BaseType*> (this) = x;
    }
  };

  // n = 8

  template<typename R, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
  class functor<R (Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8)>
  : public functor8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R>
  {
  public:
    typedef functor8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, R> BaseType;

    typedef functor SelfType;

    functor ()
    : BaseType ()
    {
    }

    template<class X, class Y>
    functor (Y *pthis, R (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8))
    : BaseType (pthis, function_to_bind)
    {
    }

    template<class X, class Y>
    functor (const Y *pthis, R (X::*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const)
    : BaseType (pthis, function_to_bind)
    {
    }

    functor (R (*function_to_bind) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8))
    : BaseType (function_to_bind)
    {
    }

    void operator = (const BaseType &x)
    {
      *static_cast<BaseType*> (this) = x;
    }
  };

  // }}} End auto-generated code

  // Auto-generated code for  make_functor helper function {{{
  // n = 0

  template<class X, class Y, class RetType>
  functor0<RetType>
  make_functor (Y *x, RetType (X::*func) ())
  {
    return functor0<RetType> (x, func);
  }

  template<class X, class Y, class RetType>
  functor0<RetType>
  make_functor (Y *x, RetType (X::*func) () const)
  {
    return functor0<RetType> (x, func);
  }

  // n = 1

  template<class X, class Y, class Param1, class RetType>
  functor1<Param1, RetType>
  make_functor (Y *x, RetType (X::*func) (Param1 p1))
  {
    return functor1<Param1, RetType> (x, func);
  }

  template<class X, class Y, class Param1, class RetType>
  functor1<Param1, RetType>
  make_functor (Y *x, RetType (X::*func) (Param1 p1) const)
  {
    return functor1<Param1, RetType> (x, func);
  }

  // n = 2

  template<class X, class Y, class Param1, class Param2, class RetType>
  functor2<Param1, Param2, RetType>
  make_functor (Y *x, RetType (X::*func) (Param1 p1, Param2 p2))
  {
    return functor2<Param1, Param2, RetType> (x, func);
  }

  template<class X, class Y, class Param1, class Param2, class RetType>
  functor2<Param1, Param2, RetType>
  make_functor (Y *x, RetType (X::*func) (Param1 p1, Param2 p2) const)
  {
    return functor2<Param1, Param2, RetType> (x, func);
  }

  // n = 3

  template<class X, class Y, class Param1, class Param2, class Param3, class RetType>
  functor3<Param1, Param2, Param3, RetType>
  make_functor (Y *x, RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3))
  {
    return functor3<Param1, Param2, Param3, RetType> (x, func);
  }

  template<class X, class Y, class Param1, class Param2, class Param3, class RetType>
  functor3<Param1, Param2, Param3, RetType>
  make_functor (Y *x, RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3) const)
  {
    return functor3<Param1, Param2, Param3, RetType> (x, func);
  }

  // n = 4

  template<class X, class Y, class Param1, class Param2, class Param3, class Param4, class RetType>
  functor4<Param1, Param2, Param3, Param4, RetType>
  make_functor (Y *x, RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4))
  {
    return functor4<Param1, Param2, Param3, Param4, RetType> (x, func);
  }

  template<class X, class Y, class Param1, class Param2, class Param3, class Param4, class RetType>
  functor4<Param1, Param2, Param3, Param4, RetType>
  make_functor (Y *x, RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4) const)
  {
    return functor4<Param1, Param2, Param3, Param4, RetType> (x, func);
  }

  // n = 5

  template<class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class RetType>
  functor5<Param1, Param2, Param3, Param4, Param5, RetType>
  make_functor (Y *x, RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5))
  {
    return functor5<Param1, Param2, Param3, Param4, Param5, RetType> (x, func);
  }

  template<class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class RetType>
  functor5<Param1, Param2, Param3, Param4, Param5, RetType>
  make_functor (Y *x, RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const)
  {
    return functor5<Param1, Param2, Param3, Param4, Param5, RetType> (x, func);
  }

  // n = 6

  template<class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class RetType>
  functor6<Param1, Param2, Param3, Param4, Param5, Param6, RetType>
  make_functor (Y *x, RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6))
  {
    return functor6<Param1, Param2, Param3, Param4, Param5, Param6, RetType> (x, func);
  }

  template<class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class RetType>
  functor6<Param1, Param2, Param3, Param4, Param5, Param6, RetType>
  make_functor (Y *x, RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const)
  {
    return functor6<Param1, Param2, Param3, Param4, Param5, Param6, RetType> (x, func);
  }

  // n = 7

  template<class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class RetType>
  functor7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, RetType>
  make_functor (Y *x, RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7))
  {
    return functor7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, RetType> (x, func);
  }

  template<class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class RetType>
  functor7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, RetType>
  make_functor (Y *x, RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const)
  {
    return functor7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, RetType> (x, func);
  }

  // n = 8

  template<class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType>
  functor8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, RetType>
  make_functor (Y *x, RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8))
  {
    return functor8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, RetType> (x, func);
  }

  template<class X, class Y, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType>
  functor8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, RetType>
  make_functor (Y *x, RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const)
  {
    return functor8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, RetType> (x, func);
  }

  // }}} End auto-generated code

  // Auto-generated code for  boost::bind-like helper function {{{
  // n = 0

  template<class X, class Y, class RetType>
  functor<RetType ()>
  bind (RetType (X::*func) (), Y *y, ...)
  {
    return functor<RetType ()> (y, func);
  }

  template<class X, class Y, class RetType>
  functor<RetType ()>
  bind (RetType (X::*func) () const, Y *y, ...)
  {
    return functor<RetType ()> (y, func);
  }

  // n = 1

  template<class X, class Y, class RetType, class Param1>
  functor<RetType (Param1 p1)>
  bind (RetType (X::*func) (Param1 p1), Y *y, ...)
  {
    return functor<RetType (Param1 p1)> (y, func);
  }

  template<class X, class Y, class RetType, class Param1>
  functor<RetType (Param1 p1)>
  bind (RetType (X::*func) (Param1 p1) const, Y *y, ...)
  {
    return functor<RetType (Param1 p1)> (y, func);
  }

  // n = 2

  template<class X, class Y, class RetType, class Param1, class Param2>
  functor<RetType (Param1 p1, Param2 p2)>
  bind (RetType (X::*func) (Param1 p1, Param2 p2), Y *y, ...)
  {
    return functor<RetType (Param1 p1, Param2 p2)> (y, func);
  }

  template<class X, class Y, class RetType, class Param1, class Param2>
  functor<RetType (Param1 p1, Param2 p2)>
  bind (RetType (X::*func) (Param1 p1, Param2 p2) const, Y *y, ...)
  {
    return functor<RetType (Param1 p1, Param2 p2)> (y, func);
  }

  // n = 3

  template<class X, class Y, class RetType, class Param1, class Param2, class Param3>
  functor<RetType (Param1 p1, Param2 p2, Param3 p3)>
  bind (RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3), Y *y, ...)
  {
    return functor<RetType (Param1 p1, Param2 p2, Param3 p3)> (y, func);
  }

  template<class X, class Y, class RetType, class Param1, class Param2, class Param3>
  functor<RetType (Param1 p1, Param2 p2, Param3 p3)>
  bind (RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3) const, Y *y, ...)
  {
    return functor<RetType (Param1 p1, Param2 p2, Param3 p3)> (y, func);
  }

  // n = 4

  template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4>
  functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4)>
  bind (RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4), Y *y, ...)
  {
    return functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4)> (y, func);
  }

  template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4>
  functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4)>
  bind (RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4) const, Y *y, ...)
  {
    return functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4)> (y, func);
  }

  // n = 5

  template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
  functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)>
  bind (RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5), Y *y, ...)
  {
    return functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)> (y, func);
  }

  template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5>
  functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)>
  bind (RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5) const, Y *y, ...)
  {
    return functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)> (y, func);
  }

  // n = 6

  template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
  functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)>
  bind (RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6), Y *y, ...)
  {
    return functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)> (y, func);
  }

  template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6>
  functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)>
  bind (RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6) const, Y *y, ...)
  {
    return functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)> (y, func);
  }

  // n = 7

  template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
  functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7)>
  bind (RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7), Y *y, ...)
  {
    return functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7)> (y, func);
  }

  template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7>
  functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7)>
  bind (RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7) const, Y *y, ...)
  {
    return functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7)> (y, func);
  }

  // n = 8

  template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
  functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)>
  bind (RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8), Y *y, ...)
  {
    return functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)> (y, func);
  }

  template<class X, class Y, class RetType, class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8>
  functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)>
  bind (RetType (X::*func) (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8) const, Y *y, ...)
  {
    return functor<RetType (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)> (y, func);
  }

  // }}} End auto-generated code

  namespace combiner
  {
    template<class RetType>
    class default_combiner
    {
      // All non-void functors need a combiner.
    };
    
    template<>
    class default_combiner<bool>
    {
      typedef std::vector<bool> return_vector;
      
    public:
      bool &operator () (return_vector &retvec)
      {
        static bool retval = true;
        return_vector::iterator it = retvec.begin ();
        return_vector::iterator et = retvec.end ();
        
        while (it != et)
          {
            if ((retval = *it) == false)
              return retval;
            ++it;
          }

        return retval;
      }
    };
    
    template<>
    struct default_combiner<void>
    {
      template<class T>
      void operator () (std::vector<T> const &retvec)
      {
      }
    };

    namespace boolean
    {
      class strongfalse
      {
        typedef std::vector<bool> return_vector;

      public:
        bool &operator () (return_vector &retvec)
        {
          static bool retval = true;
          return_vector::iterator it = retvec.begin ();
          return_vector::iterator et = retvec.end ();
          
          while (it != et)
            {
              if ((retval = *it) == false)
                return retval;
              ++it;
            }

          return retval;
        }
      };

      class strongtrue
      {
        typedef std::vector<bool> return_vector;
      
      public:
        bool &operator () (return_vector &retvec)
        {
          static bool retval = false;
          return_vector::iterator it = retvec.begin ();
          return_vector::iterator et = retvec.end ();
          
          while (it != et)
            {
              if ((retval = *it) == true)
                return retval;
              ++it;
            }

          return retval;
        }
      };
    }

    namespace integer
    {
      class min
      {
        typedef std::vector<int> return_vector;
      
      public:
        int &operator () (return_vector &retvec)
        {
          static int retval = INT_MAX;
          return_vector::iterator it = retvec.begin ();
          return_vector::iterator et = retvec.end ();
          
          while (it != et)
            {
              int val;
              if ((val = *it) < retval)
                retval = val;
              ++it;
            }

          return retval;
        }
      };

      class max
      {
        typedef std::vector<int> return_vector;
      
      public:
        int &operator () (return_vector &retvec)
        {
          static int retval = INT_MIN;
          return_vector::iterator it = retvec.begin ();
          return_vector::iterator et = retvec.end ();
          
          while (it != et)
            {
              int val;
              if ((val = *it) > retval)
                retval = val;
              ++it;
            }

          return retval;
        }
      };

      class avg
      {
        typedef std::vector<int> return_vector;
      
      public:
        int &operator () (return_vector &retvec)
        {
          static int retval = 0;
          return_vector::iterator it = retvec.begin ();
          return_vector::iterator et = retvec.end ();
          
          while (it != et)
            {
              retval += *it;
              ++it;
            }

          retval /= retvec.size ();

          return retval;
        }
      };

      class sum
      {
        typedef std::vector<int> return_vector;
      
      public:
        int &operator () (return_vector &retvec)
        {
          static int retval = 0;
          return_vector::iterator it = retvec.begin ();
          return_vector::iterator et = retvec.end ();
          
          while (it != et)
            {
              retval += *it;
              ++it;
            }

          return retval;
        }
      };
    }
  }
  
  // Auto-generated code for  Callbacks {{{
  // n = 0

  template<class RetType, class Combiner>
  struct invoker0
  {
    RetType &operator () (std::vector<functor0<RetType> *> callbacks)
    {
      typename std::vector<functor0<RetType> *>::iterator it = callbacks.begin ();
      typename std::vector<functor0<RetType> *>::iterator et = callbacks.end ();
      std::vector<RetType> retvec;
      while (it != et)
        {
          retvec.push_back ((*(*it)) ());
          ++it;
        }
      return Combiner () (retvec);
    }
  };

  template<class Combiner>
  struct invoker0<void, Combiner>
  {
    void operator () (std::vector<functor0<void> *> callbacks)
    {
      std::vector<functor0<void> *>::iterator it = callbacks.begin ();
      std::vector<functor0<void> *>::iterator et = callbacks.end ();
      while (it != et)
        {
          (*(*it)) ();
          ++it;
        }
    }
  };

  template<class RetType = void, class Combiner = combiner::default_combiner<RetType> >
  class callback0
  {
    typedef functor0<RetType> functor_type;
    typedef std::vector<functor_type *> list_type;

    list_type callbacks;

  public:
    ~callback0 ()
    {
      detach_all ();
    }

    bool contains (RetType (*function) ())
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();
      functor_type functor (function);

      while (it != et)
        {
          if (*(*it) == functor)
            return true;
          ++it;
        }

      return false;
    }

    void attach (RetType (*function) ())
    {
      if (contains (function))
        return;
      functor_type *functor = new functor_type (function);
      callbacks.push_back (functor);
    }

    void attach_first (RetType (*function) ())
    {
      if (contains (function))
        return;
      functor_type *functor = new functor_type (function);
      callbacks.insert (callbacks.begin (), functor);
    }

    void detach (RetType (*function) ())
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();
      functor_type functor (function);

      while (it != et)
        {
          if (*(*it) == functor)
            {
              delete *it;
              callbacks.erase (it);
              return;
            }
          ++it;
        }
    }

    void detach_all ()
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();

      while (it != et)
        {
          delete *it;
          ++it;
        }

      callbacks.clear ();
    }

    RetType invoke ()
    {
      return invoker0<RetType, Combiner> () (callbacks);
    }

    RetType operator () ()
    {
      return invoke ();
    }
  };

  // n = 1

  template<class Param1, class RetType, class Combiner>
  struct invoker1
  {
    RetType &operator () (std::vector<functor1<Param1, RetType> *> callbacks, Param1 p1)
    {
      typename std::vector<functor1<Param1, RetType> *>::iterator it = callbacks.begin ();
      typename std::vector<functor1<Param1, RetType> *>::iterator et = callbacks.end ();
      std::vector<RetType> retvec;
      while (it != et)
        {
          retvec.push_back ((*(*it)) (p1));
          ++it;
        }
      return Combiner () (retvec);
    }
  };

  template<class Param1, class Combiner>
  struct invoker1<Param1, void, Combiner>
  {
    void operator () (std::vector<functor1<Param1, void> *> callbacks, Param1 p1)
    {
      typename std::vector<functor1<Param1, void> *>::iterator it = callbacks.begin ();
      typename std::vector<functor1<Param1, void> *>::iterator et = callbacks.end ();
      while (it != et)
        {
          (*(*it)) (p1);
          ++it;
        }
    }
  };

  template<class Param1, class RetType = void, class Combiner = combiner::default_combiner<RetType> >
  class callback1
  {
    typedef functor1<Param1, RetType> functor_type;
    typedef std::vector<functor_type *> list_type;

    list_type callbacks;

  public:
    ~callback1 ()
    {
      detach_all ();
    }

    bool contains (RetType (*function) (Param1))
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();
      functor_type functor (function);

      while (it != et)
        {
          if (*(*it) == functor)
            return true;
          ++it;
        }

      return false;
    }

    void attach (RetType (*function) (Param1))
    {
      if (contains (function))
        return;
      functor_type *functor = new functor_type (function);
      callbacks.push_back (functor);
    }

    void attach_first (RetType (*function) (Param1))
    {
      if (contains (function))
        return;
      functor_type *functor = new functor_type (function);
      callbacks.insert (callbacks.begin (), functor);
    }

    void detach (RetType (*function) (Param1))
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();
      functor_type functor (function);

      while (it != et)
        {
          if (*(*it) == functor)
            {
              delete *it;
              callbacks.erase (it);
              return;
            }
          ++it;
        }
    }

    void detach_all ()
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();

      while (it != et)
        {
          delete *it;
          ++it;
        }

      callbacks.clear ();
    }

    RetType invoke (Param1 p1)
    {
      return invoker1<Param1, RetType, Combiner> () (callbacks, p1);
    }

    RetType operator () (Param1 p1)
    {
      return invoke (p1);
    }
  };

  // n = 2

  template<class Param1, class Param2, class RetType, class Combiner>
  struct invoker2
  {
    RetType &operator () (std::vector<functor2<Param1, Param2, RetType> *> callbacks, Param1 p1, Param2 p2)
    {
      typename std::vector<functor2<Param1, Param2, RetType> *>::iterator it = callbacks.begin ();
      typename std::vector<functor2<Param1, Param2, RetType> *>::iterator et = callbacks.end ();
      std::vector<RetType> retvec;
      while (it != et)
        {
          retvec.push_back ((*(*it)) (p1, p2));
          ++it;
        }
      return Combiner () (retvec);
    }
  };

  template<class Param1, class Param2, class Combiner>
  struct invoker2<Param1, Param2, void, Combiner>
  {
    void operator () (std::vector<functor2<Param1, Param2, void> *> callbacks, Param1 p1, Param2 p2)
    {
      typename std::vector<functor2<Param1, Param2, void> *>::iterator it = callbacks.begin ();
      typename std::vector<functor2<Param1, Param2, void> *>::iterator et = callbacks.end ();
      while (it != et)
        {
          (*(*it)) (p1, p2);
          ++it;
        }
    }
  };

  template<class Param1, class Param2, class RetType = void, class Combiner = combiner::default_combiner<RetType> >
  class callback2
  {
    typedef functor2<Param1, Param2, RetType> functor_type;
    typedef std::vector<functor_type *> list_type;

    list_type callbacks;

  public:
    ~callback2 ()
    {
      detach_all ();
    }

    bool contains (RetType (*function) (Param1, Param2))
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();
      functor_type functor (function);

      while (it != et)
        {
          if (*(*it) == functor)
            return true;
          ++it;
        }

      return false;
    }

    void attach (RetType (*function) (Param1, Param2))
    {
      if (contains (function))
        return;
      functor_type *functor = new functor_type (function);
      callbacks.push_back (functor);
    }

    void attach_first (RetType (*function) (Param1, Param2))
    {
      if (contains (function))
        return;
      functor_type *functor = new functor_type (function);
      callbacks.insert (callbacks.begin (), functor);
    }

    void detach (RetType (*function) (Param1, Param2))
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();
      functor_type functor (function);

      while (it != et)
        {
          if (*(*it) == functor)
            {
              delete *it;
              callbacks.erase (it);
              return;
            }
          ++it;
        }
    }

    void detach_all ()
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();

      while (it != et)
        {
          delete *it;
          ++it;
        }

      callbacks.clear ();
    }

    RetType invoke (Param1 p1, Param2 p2)
    {
      return invoker2<Param1, Param2, RetType, Combiner> () (callbacks, p1, p2);
    }

    RetType operator () (Param1 p1, Param2 p2)
    {
      return invoke (p1, p2);
    }
  };

  // n = 3

  template<class Param1, class Param2, class Param3, class RetType, class Combiner>
  struct invoker3
  {
    RetType &operator () (std::vector<functor3<Param1, Param2, Param3, RetType> *> callbacks, Param1 p1, Param2 p2, Param3 p3)
    {
      typename std::vector<functor3<Param1, Param2, Param3, RetType> *>::iterator it = callbacks.begin ();
      typename std::vector<functor3<Param1, Param2, Param3, RetType> *>::iterator et = callbacks.end ();
      std::vector<RetType> retvec;
      while (it != et)
        {
          retvec.push_back ((*(*it)) (p1, p2, p3));
          ++it;
        }
      return Combiner () (retvec);
    }
  };

  template<class Param1, class Param2, class Param3, class Combiner>
  struct invoker3<Param1, Param2, Param3, void, Combiner>
  {
    void operator () (std::vector<functor3<Param1, Param2, Param3, void> *> callbacks, Param1 p1, Param2 p2, Param3 p3)
    {
      typename std::vector<functor3<Param1, Param2, Param3, void> *>::iterator it = callbacks.begin ();
      typename std::vector<functor3<Param1, Param2, Param3, void> *>::iterator et = callbacks.end ();
      while (it != et)
        {
          (*(*it)) (p1, p2, p3);
          ++it;
        }
    }
  };

  template<class Param1, class Param2, class Param3, class RetType = void, class Combiner = combiner::default_combiner<RetType> >
  class callback3
  {
    typedef functor3<Param1, Param2, Param3, RetType> functor_type;
    typedef std::vector<functor_type *> list_type;

    list_type callbacks;

  public:
    ~callback3 ()
    {
      detach_all ();
    }

    bool contains (RetType (*function) (Param1, Param2, Param3))
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();
      functor_type functor (function);

      while (it != et)
        {
          if (*(*it) == functor)
            return true;
          ++it;
        }

      return false;
    }

    void attach (RetType (*function) (Param1, Param2, Param3))
    {
      if (contains (function))
        return;
      functor_type *functor = new functor_type (function);
      callbacks.push_back (functor);
    }

    void attach_first (RetType (*function) (Param1, Param2, Param3))
    {
      if (contains (function))
        return;
      functor_type *functor = new functor_type (function);
      callbacks.insert (callbacks.begin (), functor);
    }

    void detach (RetType (*function) (Param1, Param2, Param3))
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();
      functor_type functor (function);

      while (it != et)
        {
          if (*(*it) == functor)
            {
              delete *it;
              callbacks.erase (it);
              return;
            }
          ++it;
        }
    }

    void detach_all ()
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();

      while (it != et)
        {
          delete *it;
          ++it;
        }

      callbacks.clear ();
    }

    RetType invoke (Param1 p1, Param2 p2, Param3 p3)
    {
      return invoker3<Param1, Param2, Param3, RetType, Combiner> () (callbacks, p1, p2, p3);
    }

    RetType operator () (Param1 p1, Param2 p2, Param3 p3)
    {
      return invoke (p1, p2, p3);
    }
  };

  // n = 4

  template<class Param1, class Param2, class Param3, class Param4, class RetType, class Combiner>
  struct invoker4
  {
    RetType &operator () (std::vector<functor4<Param1, Param2, Param3, Param4, RetType> *> callbacks, Param1 p1, Param2 p2, Param3 p3, Param4 p4)
    {
      typename std::vector<functor4<Param1, Param2, Param3, Param4, RetType> *>::iterator it = callbacks.begin ();
      typename std::vector<functor4<Param1, Param2, Param3, Param4, RetType> *>::iterator et = callbacks.end ();
      std::vector<RetType> retvec;
      while (it != et)
        {
          retvec.push_back ((*(*it)) (p1, p2, p3, p4));
          ++it;
        }
      return Combiner () (retvec);
    }
  };

  template<class Param1, class Param2, class Param3, class Param4, class Combiner>
  struct invoker4<Param1, Param2, Param3, Param4, void, Combiner>
  {
    void operator () (std::vector<functor4<Param1, Param2, Param3, Param4, void> *> callbacks, Param1 p1, Param2 p2, Param3 p3, Param4 p4)
    {
      typename std::vector<functor4<Param1, Param2, Param3, Param4, void> *>::iterator it = callbacks.begin ();
      typename std::vector<functor4<Param1, Param2, Param3, Param4, void> *>::iterator et = callbacks.end ();
      while (it != et)
        {
          (*(*it)) (p1, p2, p3, p4);
          ++it;
        }
    }
  };

  template<class Param1, class Param2, class Param3, class Param4, class RetType = void, class Combiner = combiner::default_combiner<RetType> >
  class callback4
  {
    typedef functor4<Param1, Param2, Param3, Param4, RetType> functor_type;
    typedef std::vector<functor_type *> list_type;

    list_type callbacks;

  public:
    ~callback4 ()
    {
      detach_all ();
    }

    bool contains (RetType (*function) (Param1, Param2, Param3, Param4))
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();
      functor_type functor (function);

      while (it != et)
        {
          if (*(*it) == functor)
            return true;
          ++it;
        }

      return false;
    }

    void attach (RetType (*function) (Param1, Param2, Param3, Param4))
    {
      if (contains (function))
        return;
      functor_type *functor = new functor_type (function);
      callbacks.push_back (functor);
    }

    void attach_first (RetType (*function) (Param1, Param2, Param3, Param4))
    {
      if (contains (function))
        return;
      functor_type *functor = new functor_type (function);
      callbacks.insert (callbacks.begin (), functor);
    }

    void detach (RetType (*function) (Param1, Param2, Param3, Param4))
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();
      functor_type functor (function);

      while (it != et)
        {
          if (*(*it) == functor)
            {
              delete *it;
              callbacks.erase (it);
              return;
            }
          ++it;
        }
    }

    void detach_all ()
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();

      while (it != et)
        {
          delete *it;
          ++it;
        }

      callbacks.clear ();
    }

    RetType invoke (Param1 p1, Param2 p2, Param3 p3, Param4 p4)
    {
      return invoker4<Param1, Param2, Param3, Param4, RetType, Combiner> () (callbacks, p1, p2, p3, p4);
    }

    RetType operator () (Param1 p1, Param2 p2, Param3 p3, Param4 p4)
    {
      return invoke (p1, p2, p3, p4);
    }
  };

  // n = 5

  template<class Param1, class Param2, class Param3, class Param4, class Param5, class RetType, class Combiner>
  struct invoker5
  {
    RetType &operator () (std::vector<functor5<Param1, Param2, Param3, Param4, Param5, RetType> *> callbacks, Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)
    {
      typename std::vector<functor5<Param1, Param2, Param3, Param4, Param5, RetType> *>::iterator it = callbacks.begin ();
      typename std::vector<functor5<Param1, Param2, Param3, Param4, Param5, RetType> *>::iterator et = callbacks.end ();
      std::vector<RetType> retvec;
      while (it != et)
        {
          retvec.push_back ((*(*it)) (p1, p2, p3, p4, p5));
          ++it;
        }
      return Combiner () (retvec);
    }
  };

  template<class Param1, class Param2, class Param3, class Param4, class Param5, class Combiner>
  struct invoker5<Param1, Param2, Param3, Param4, Param5, void, Combiner>
  {
    void operator () (std::vector<functor5<Param1, Param2, Param3, Param4, Param5, void> *> callbacks, Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)
    {
      typename std::vector<functor5<Param1, Param2, Param3, Param4, Param5, void> *>::iterator it = callbacks.begin ();
      typename std::vector<functor5<Param1, Param2, Param3, Param4, Param5, void> *>::iterator et = callbacks.end ();
      while (it != et)
        {
          (*(*it)) (p1, p2, p3, p4, p5);
          ++it;
        }
    }
  };

  template<class Param1, class Param2, class Param3, class Param4, class Param5, class RetType = void, class Combiner = combiner::default_combiner<RetType> >
  class callback5
  {
    typedef functor5<Param1, Param2, Param3, Param4, Param5, RetType> functor_type;
    typedef std::vector<functor_type *> list_type;

    list_type callbacks;

  public:
    ~callback5 ()
    {
      detach_all ();
    }

    bool contains (RetType (*function) (Param1, Param2, Param3, Param4, Param5))
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();
      functor_type functor (function);

      while (it != et)
        {
          if (*(*it) == functor)
            return true;
          ++it;
        }

      return false;
    }

    void attach (RetType (*function) (Param1, Param2, Param3, Param4, Param5))
    {
      if (contains (function))
        return;
      functor_type *functor = new functor_type (function);
      callbacks.push_back (functor);
    }

    void attach_first (RetType (*function) (Param1, Param2, Param3, Param4, Param5))
    {
      if (contains (function))
        return;
      functor_type *functor = new functor_type (function);
      callbacks.insert (callbacks.begin (), functor);
    }

    void detach (RetType (*function) (Param1, Param2, Param3, Param4, Param5))
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();
      functor_type functor (function);

      while (it != et)
        {
          if (*(*it) == functor)
            {
              delete *it;
              callbacks.erase (it);
              return;
            }
          ++it;
        }
    }

    void detach_all ()
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();

      while (it != et)
        {
          delete *it;
          ++it;
        }

      callbacks.clear ();
    }

    RetType invoke (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)
    {
      return invoker5<Param1, Param2, Param3, Param4, Param5, RetType, Combiner> () (callbacks, p1, p2, p3, p4, p5);
    }

    RetType operator () (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5)
    {
      return invoke (p1, p2, p3, p4, p5);
    }
  };

  // n = 6

  template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class RetType, class Combiner>
  struct invoker6
  {
    RetType &operator () (std::vector<functor6<Param1, Param2, Param3, Param4, Param5, Param6, RetType> *> callbacks, Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)
    {
      typename std::vector<functor6<Param1, Param2, Param3, Param4, Param5, Param6, RetType> *>::iterator it = callbacks.begin ();
      typename std::vector<functor6<Param1, Param2, Param3, Param4, Param5, Param6, RetType> *>::iterator et = callbacks.end ();
      std::vector<RetType> retvec;
      while (it != et)
        {
          retvec.push_back ((*(*it)) (p1, p2, p3, p4, p5, p6));
          ++it;
        }
      return Combiner () (retvec);
    }
  };

  template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Combiner>
  struct invoker6<Param1, Param2, Param3, Param4, Param5, Param6, void, Combiner>
  {
    void operator () (std::vector<functor6<Param1, Param2, Param3, Param4, Param5, Param6, void> *> callbacks, Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)
    {
      typename std::vector<functor6<Param1, Param2, Param3, Param4, Param5, Param6, void> *>::iterator it = callbacks.begin ();
      typename std::vector<functor6<Param1, Param2, Param3, Param4, Param5, Param6, void> *>::iterator et = callbacks.end ();
      while (it != et)
        {
          (*(*it)) (p1, p2, p3, p4, p5, p6);
          ++it;
        }
    }
  };

  template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class RetType = void, class Combiner = combiner::default_combiner<RetType> >
  class callback6
  {
    typedef functor6<Param1, Param2, Param3, Param4, Param5, Param6, RetType> functor_type;
    typedef std::vector<functor_type *> list_type;

    list_type callbacks;

  public:
    ~callback6 ()
    {
      detach_all ();
    }

    bool contains (RetType (*function) (Param1, Param2, Param3, Param4, Param5, Param6))
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();
      functor_type functor (function);

      while (it != et)
        {
          if (*(*it) == functor)
            return true;
          ++it;
        }

      return false;
    }

    void attach (RetType (*function) (Param1, Param2, Param3, Param4, Param5, Param6))
    {
      if (contains (function))
        return;
      functor_type *functor = new functor_type (function);
      callbacks.push_back (functor);
    }

    void attach_first (RetType (*function) (Param1, Param2, Param3, Param4, Param5, Param6))
    {
      if (contains (function))
        return;
      functor_type *functor = new functor_type (function);
      callbacks.insert (callbacks.begin (), functor);
    }

    void detach (RetType (*function) (Param1, Param2, Param3, Param4, Param5, Param6))
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();
      functor_type functor (function);

      while (it != et)
        {
          if (*(*it) == functor)
            {
              delete *it;
              callbacks.erase (it);
              return;
            }
          ++it;
        }
    }

    void detach_all ()
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();

      while (it != et)
        {
          delete *it;
          ++it;
        }

      callbacks.clear ();
    }

    RetType invoke (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)
    {
      return invoker6<Param1, Param2, Param3, Param4, Param5, Param6, RetType, Combiner> () (callbacks, p1, p2, p3, p4, p5, p6);
    }

    RetType operator () (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6)
    {
      return invoke (p1, p2, p3, p4, p5, p6);
    }
  };

  // n = 7

  template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class RetType, class Combiner>
  struct invoker7
  {
    RetType &operator () (std::vector<functor7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, RetType> *> callbacks, Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7)
    {
      typename std::vector<functor7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, RetType> *>::iterator it = callbacks.begin ();
      typename std::vector<functor7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, RetType> *>::iterator et = callbacks.end ();
      std::vector<RetType> retvec;
      while (it != et)
        {
          retvec.push_back ((*(*it)) (p1, p2, p3, p4, p5, p6, p7));
          ++it;
        }
      return Combiner () (retvec);
    }
  };

  template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Combiner>
  struct invoker7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, void, Combiner>
  {
    void operator () (std::vector<functor7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, void> *> callbacks, Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7)
    {
      typename std::vector<functor7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, void> *>::iterator it = callbacks.begin ();
      typename std::vector<functor7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, void> *>::iterator et = callbacks.end ();
      while (it != et)
        {
          (*(*it)) (p1, p2, p3, p4, p5, p6, p7);
          ++it;
        }
    }
  };

  template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class RetType = void, class Combiner = combiner::default_combiner<RetType> >
  class callback7
  {
    typedef functor7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, RetType> functor_type;
    typedef std::vector<functor_type *> list_type;

    list_type callbacks;

  public:
    ~callback7 ()
    {
      detach_all ();
    }

    bool contains (RetType (*function) (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();
      functor_type functor (function);

      while (it != et)
        {
          if (*(*it) == functor)
            return true;
          ++it;
        }

      return false;
    }

    void attach (RetType (*function) (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
    {
      if (contains (function))
        return;
      functor_type *functor = new functor_type (function);
      callbacks.push_back (functor);
    }

    void attach_first (RetType (*function) (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
    {
      if (contains (function))
        return;
      functor_type *functor = new functor_type (function);
      callbacks.insert (callbacks.begin (), functor);
    }

    void detach (RetType (*function) (Param1, Param2, Param3, Param4, Param5, Param6, Param7))
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();
      functor_type functor (function);

      while (it != et)
        {
          if (*(*it) == functor)
            {
              delete *it;
              callbacks.erase (it);
              return;
            }
          ++it;
        }
    }

    void detach_all ()
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();

      while (it != et)
        {
          delete *it;
          ++it;
        }

      callbacks.clear ();
    }

    RetType invoke (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7)
    {
      return invoker7<Param1, Param2, Param3, Param4, Param5, Param6, Param7, RetType, Combiner> () (callbacks, p1, p2, p3, p4, p5, p6, p7);
    }

    RetType operator () (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7)
    {
      return invoke (p1, p2, p3, p4, p5, p6, p7);
    }
  };

  // n = 8

  template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType, class Combiner>
  struct invoker8
  {
    RetType &operator () (std::vector<functor8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, RetType> *> callbacks, Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)
    {
      typename std::vector<functor8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, RetType> *>::iterator it = callbacks.begin ();
      typename std::vector<functor8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, RetType> *>::iterator et = callbacks.end ();
      std::vector<RetType> retvec;
      while (it != et)
        {
          retvec.push_back ((*(*it)) (p1, p2, p3, p4, p5, p6, p7, p8));
          ++it;
        }
      return Combiner () (retvec);
    }
  };

  template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class Combiner>
  struct invoker8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, void, Combiner>
  {
    void operator () (std::vector<functor8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, void> *> callbacks, Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)
    {
      typename std::vector<functor8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, void> *>::iterator it = callbacks.begin ();
      typename std::vector<functor8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, void> *>::iterator et = callbacks.end ();
      while (it != et)
        {
          (*(*it)) (p1, p2, p3, p4, p5, p6, p7, p8);
          ++it;
        }
    }
  };

  template<class Param1, class Param2, class Param3, class Param4, class Param5, class Param6, class Param7, class Param8, class RetType = void, class Combiner = combiner::default_combiner<RetType> >
  class callback8
  {
    typedef functor8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, RetType> functor_type;
    typedef std::vector<functor_type *> list_type;

    list_type callbacks;

  public:
    ~callback8 ()
    {
      detach_all ();
    }

    bool contains (RetType (*function) (Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8))
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();
      functor_type functor (function);

      while (it != et)
        {
          if (*(*it) == functor)
            return true;
          ++it;
        }

      return false;
    }

    void attach (RetType (*function) (Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8))
    {
      if (contains (function))
        return;
      functor_type *functor = new functor_type (function);
      callbacks.push_back (functor);
    }

    void attach_first (RetType (*function) (Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8))
    {
      if (contains (function))
        return;
      functor_type *functor = new functor_type (function);
      callbacks.insert (callbacks.begin (), functor);
    }

    void detach (RetType (*function) (Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8))
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();
      functor_type functor (function);

      while (it != et)
        {
          if (*(*it) == functor)
            {
              delete *it;
              callbacks.erase (it);
              return;
            }
          ++it;
        }
    }

    void detach_all ()
    {
      typename list_type::iterator it = callbacks.begin ();
      typename list_type::iterator et = callbacks.end ();

      while (it != et)
        {
          delete *it;
          ++it;
        }

      callbacks.clear ();
    }

    RetType invoke (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)
    {
      return invoker8<Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, RetType, Combiner> () (callbacks, p1, p2, p3, p4, p5, p6, p7, p8);
    }

    RetType operator () (Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8)
    {
      return invoke (p1, p2, p3, p4, p5, p6, p7, p8);
    }
  };

  // }}} End auto-generated code
}

#endif

#if TEST_FUNCTOR

static void
static_function (int num, char *str)
{
  myprintf ("In static_function.                           num = %s%d, str = %s\n", num < 10 ? " " : "", num, str);
}

static void
void_function (void)
{
  myprintf ("In void_function with no parameters.");
}

#if TEST_CALLBACKS
static bool
bool_function (void)
{
  myputs ("In bool_function with no parameters.");
  return true;
}

static bool
bool_function2 (void)
{
  myputs ("In bool_function2 with no parameters.");
  return true;
}

static bool
bool_function_false (void)
{
  myputs ("In bool_function_false with no parameters.");
  return false;
}

static int
int_function1 (void)
{
  int i = 150;
  myprintf ("In int_function1. i = %d\n", i);
  return i;
}

static int
int_function2 (void)
{
  int i = 100;
  myprintf ("In int_function2. i = %d\n", i);
  return i;
}

static int
int_function3 (void)
{
  int i = 50;
  myprintf ("In int_function3. i = %d\n", i);
  return i;
}

static void
void_function2 (void)
{
  myputs ("In void_function2 with no parameters.");
}
#endif

class base
{
protected:
  char const * const m_name;

public:
  base (char const * const name)
  : m_name (name)
  {
  }

  virtual ~base ()
  {
  }

  void member_function (int num, char *str)
  {
    myprintf ("In member_function in %s.        num = %s%d, str = %s\n", m_name, num < 10 ? " " : "", num, str);
  }

  int int_member_function (int num, char *str)
  {
    myprintf ("In member_function in %s.           num = %s%d, str = %s\n", m_name, num < 10 ? " " : "", num, str);
    return -1;
  }

  void const_member_function (int num, char *str) const
  {
    myprintf ("In const_member_function in %s.  num = %s%d, str = %s\n", m_name, num < 10 ? " " : "", num, str);
  }

  virtual void virtual_function (int num, char *str)
  {
    myprintf ("In virtual_function in %s.       num = %s%d, str = %s\n", m_name, num < 10 ? " " : "", num, str);
  }

  static void static_member_function (int num, char *str)
  {
    myprintf ("In static_member_function.                    num = %s%d, str = %s\n", num < 10 ? " " : "", num, str);
  }
};

class other
{
  double rubbish;
public:
  virtual ~other () { }
  virtual void empty_virtual_function (void) { }
  virtual void pure_virtual_function (int num, char *str) = 0;
};

class huge
{
  int largemember[400];
};

class derived : public huge, virtual public other, virtual public base
{
  double m_somemember[8];

public:
  derived ()
  : base ("Base of Derived")
  {
    m_somemember[0] = 1.2345;
  }

  void derived_function (int num, char *str)
  {
    myprintf ("In SimpleDerived.                             num = %s%d, str = %s\n", num < 10 ? " " : "", num, str);
  }

  virtual void empty_virtual_function2 (int num, char *str)
  {
  }

  virtual void pure_virtual_function (volatile int num, char *str)
  {
    myprintf ("In Derived pure_virtual_function.             num = %s%d, str = %s\n", num < 10 ? " " : "", num, str);
  }
};

static void othertest ();

#if BENCHMARK
#include <sys/time.h>

static double
now ()
{
  struct timeval tv;

  gettimeofday (&tv, 0);
  return double (tv.tv_sec) + double (tv.tv_usec) * double (1e-6);
}
#endif

int main (void)
{
#if TIMER
  for (int m = 0; m < 100000; m++)
    {
#endif
      myputs ("-- functor demo --\nA no-parameter functor is declared using functor0\n");

      myprintf ("0  :");
      functor::functor0<> noparameterfunctor (void_function);

      noparameterfunctor ();

      myputs ("\n-- Examples using two-parameter functors (int, char *) --\n");

      typedef functor::functor2<int, char *> myfunctor;

      typedef functor::functor2<int, char *, int> intfunctor;

      myfunctor funclist[12];
      base a ("Base Class  (A)");
      base b ("Base Class  (B)");
      derived d;
      derived c;

      intfunctor newfunc;
      newfunc = functor::make_functor (&a, &base::int_member_function);

      funclist[0].bind (&a, &base::member_function);

      funclist[1].bind (&static_function);
      funclist[2].bind (&base::static_member_function);
      funclist[11].bind ( (const base *) &a, &base::const_member_function);
      funclist[3].bind (&a, &base::const_member_function);
      funclist[4].bind (&b, &base::virtual_function);

      funclist[5] = &base::static_member_function;

      funclist[6] = functor::make_functor (&d, &base::virtual_function);

      funclist[7].bind (&c, &derived::pure_virtual_function);
      funclist[8].bind (&c, &other::pure_virtual_function);
      funclist[9] = functor::make_functor (&c, &derived::derived_function);

      myfunctor dg (&b, &base::virtual_function);

      for (int i = 0; i < 12; i++)
        {
          myprintf (i < 9 ? "%d  :" : "%d :", i + 1);
          char const *msg = funclist[i] == dg
            ? "\033[1;32mFound equal functor\033[0m"
            : "\033[0;33mLooking for equal functor\033[0m";
          if (!funclist[i])
            {
              myputs ("Functor is empty");
            }
          else
            funclist[i] (i, const_cast<char *> (msg));
        }
      
#if TEST_CALLBACKS
      myputs ("");
      functor::callback0<> cb;
      functor::callback0<bool> boolcb;
      boolcb.attach (bool_function);
      boolcb.attach (bool_function_false);
      boolcb.attach (bool_function2);
      cb.attach (void_function);
      cb.attach (void_function2);
      cb.attach (void_function);
      cb.attach (void_function2);
      cb ();
      bool success = boolcb ();
      myprintf ("bool callback combiner returned %s\n\n", success ? "true" : "false");
      cb.detach (void_function);
      cb ();
      
      myputs ("\nTrying to calculate the average of a few numbers using callbacks:");
      functor::callback0<int, functor::combiner::integer::avg> intavgcb;
      intavgcb.attach (int_function1);
      intavgcb.attach (int_function2);
      intavgcb.attach (int_function3);
      myprintf ("Average: %d\n", intavgcb ());
      
      myputs ("\nTrying to calculate the sum of a few numbers using callbacks:");
      functor::callback0<int, functor::combiner::integer::sum> intsumcb;
      intsumcb.attach (int_function1);
      intsumcb.attach (int_function2);
      intsumcb.attach (int_function3);
      myprintf ("Sum: %d\n", intsumcb ());
      
      myputs ("\nTrying to calculate the max of a few numbers using callbacks:");
      functor::callback0<int, functor::combiner::integer::max> intmaxcb;
      intmaxcb.attach (int_function1);
      intmaxcb.attach (int_function2);
      intmaxcb.attach (int_function3);
      myprintf ("Max: %d\n", intmaxcb ());
      
      myputs ("\nTrying to calculate the min of a few numbers using callbacks:");
      functor::callback0<int, functor::combiner::integer::min> intmincb;
      intmincb.attach (int_function1);
      intmincb.attach (int_function2);
      intmincb.attach (int_function3);
      myprintf ("Min: %d\n", intmincb ());
#endif
#if TIMER
    }
#endif
  myprintf ("\nsizeof (functor0<>) == %ld\n", sizeof (functor::functor0<>));
  myprintf ("sizeof (functor1<int>) == %ld\n", sizeof (functor::functor1<int>));

  othertest ();

#if BENCHMARK
  typedef functor::functor2<int, char *> myfunctor;
  derived c2;
  myfunctor somefunctor (&c, &derived::pure_virtual_function);
  
  size_t ctr;
  double start, end;

  start = now ();
  ctr = 300000000;
  while (ctr--)
    somefunctor (2, const_cast<char *> ("moo"));
  end = now ();
  printf ("%f seconds (functor)\n", end - start);

  void (derived::*funcptr) (int, char *) = &derived::pure_virtual_function;
  start = now ();
  ctr = 300000000;
  while (ctr--)
    (c2.*funcptr) (2, const_cast<char *> ("moo"));
  end = now ();
  printf ("%f seconds (function pointer)\n", end - start);

  start = now ();
  ctr = 300000000;
  while (ctr--)
    c2.pure_virtual_function (2, const_cast<char *> ("moo"));
  end = now ();
  printf ("%f seconds (native call)\n", end - start);
#endif
  
  return 0;
}


static bool
allow1 (int num)
{
  return num == 3;
}

static bool
allow2 (int num)
{
  return num == 3;
}

static bool
allow3 (int num)
{
  return num == 3;
}

static bool
deny (int num)
{
  return num == 2;
}

static void
othertest ()
{
  functor::callback1<int, bool> cb;

  myputs ("\nOther test\n");

  cb.attach (allow1);
  cb.attach (allow2);
  cb.attach (allow3);
  myputs (cb (3) ? "allowed" : "denied");

  cb.attach (deny);
  myputs (cb (3) ? "allowed" : "denied");
}

#endif

// Generating this file took 0 wallclock secs ( 0.01 usr +  0.00 sys =  0.01 CPU)
Revision:	1.1
Committed:	Tue Aug 28 17:14:43 2007 UTC (16 years, 9 months ago) by pippijn
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	added new files