gls_functor.h

Go to the documentation of this file.

#if !defined(GLS_FUNCTOR_H)
#define GLS_FUNCTOR_H

//----------------------------------------------------------------------------
//                         0 ARGUMENT FUNCTORS
//----------------------------------------------------------------------------
template <class T>
class GlsFunctor_T
{
public:
    virtual T operator()() = 0;
};

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class T>
class GlsStaticMemberFunctor_T : public GlsFunctor_T<T>
{
public:
    typedef T (*F)();
    GlsStaticMemberFunctor_T(F f) : _f(f) {}
    virtual T operator()() { return (*_f)(); }
private:
    F  _f;
};

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T>
class GlsMemberFunctor_T : public GlsFunctor_T<T>
{
public:
    typedef T (O::*F)();
    GlsMemberFunctor_T(O& o, F f) : _o(o), _f(f) {}
    virtual T operator()() { return (_o.*_f)(); }
private:
    O& _o;
    F  _f;
};

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T>
class GlsConstMemberFunctor_T : public GlsFunctor_T<T>
{
public:
    typedef T (O::*F)() const;
    GlsConstMemberFunctor_T(const O& o, F f) : _o(o), _f(f) {}

    virtual T operator()(T arg) { return (_o.*_f)(arg); }

private:
    const O& _o;
    F  _f;
};

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class T>
GlsStaticMemberFunctor_T<T>* GlsFunctor(T (*f)())
{
    return new GlsStaticMemberFunctor_T<T>(f);
}

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T>
GlsMemberFunctor_T<O,T>* GlsFunctor(O& o, T (O::*f)())
{
    return new GlsMemberFunctor_T<O,T>(o, f);
}

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T>
GlsConstMemberFunctor_T<O,T>* GlsFunctor(const O& o, T (O::*f)() const)
{
    return new GlsConstMemberFunctor_T<O,T>(o, f);
}


//----------------------------------------------------------------------------
//                         1 ARGUMENT FUNCTORS
//----------------------------------------------------------------------------
template <class T>
class GlsFunctor1_T
{
public:
    virtual void operator()(T arg) = 0;
};

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class T>
class GlsStaticMemberFunctor1_T : public GlsFunctor1_T<T>
{
public:
    typedef void (*F)(T);
    GlsStaticMemberFunctor1_T(F f) : _f(f) {}
    virtual void operator()(T arg) { (*_f)(arg); }
private:
    F  _f;
};

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T>
class GlsMemberFunctor1_T : public GlsFunctor1_T<T>
{
public:
    typedef void (O::*F)(T);
    GlsMemberFunctor1_T(O& o, F f) : _o(o), _f(f) {}
    virtual void operator()(T arg) { (_o.*_f)(arg); }
private:
    O& _o;
    F  _f;
};

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T>
class GlsConstMemberFunctor1_T : public GlsFunctor1_T<T>
{
public:
    typedef void (O::*F)(T) const;
    GlsConstMemberFunctor1_T(const O& o, F f) : _o(o), _f(f) {}
    virtual void operator()(T arg) { (_o.*_f)(arg); }
private:
    const O& _o;
    F  _f;
};

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class T>
GlsStaticMemberFunctor1_T<T>* GlsFunctor(void (*f)(T))
{
    return new GlsStaticMemberFunctor1_T<T>(f);
}

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T>
GlsMemberFunctor1_T<O,T>* GlsFunctor(O& o, void (O::*f)(T))
{
    return new GlsMemberFunctor1_T<O,T>(o, f);
}

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T>
GlsConstMemberFunctor1_T<O,T>* GlsFunctor(const O& o, void (O::*f)(T) const)
{
    return new GlsConstMemberFunctor1_T<O,T>(o, f);
}

//----------------------------------------------------------------------------
//                         2 ARGUMENT FUNCTORS
//----------------------------------------------------------------------------
template <class T1, class T2>
class GlsFunctor2_T
{
public:
    virtual void operator()(T1 arg1, T2 arg2) = 0;
};

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T1, class T2>
class GlsStaticMemberFunctor2_T : public GlsFunctor2_T<T1,T2>
{
public:
    typedef void (O::*F)(T1,T2);
    GlsStaticMemberFunctor2_T(F f) : _f(f) {}
    virtual void operator()(T1 arg1, T2 arg2) { (*_f)(arg1, arg2); }
private:
    F  _f;
};

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T1, class T2>
class GlsMemberFunctor2_T : public GlsFunctor2_T<T1,T2>
{
public:
    typedef void (O::*F)(T1,T2);
    GlsMemberFunctor2_T(O& o, F f) : _o(o), _f(f) {}
    virtual void operator()(T1 arg1, T2 arg2) { (_o.*_f)(arg1, arg2); }
private:
    O& _o;
    F  _f;
};

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T1, class T2>
class GlsConstMemberFunctor2_T : public GlsFunctor2_T<T1,T2>
{
public:
    typedef void (O::*F)(T1,T2) const;
    GlsConstMemberFunctor2_T(const O& o, F f) : _o(o), _f(f) {}
    virtual void operator()(T1 arg1, T2 arg2) { (_o.*_f)(arg1, arg2); }
private:
    const O& _o;
    F  _f;
};

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T1, class T2>
GlsStaticMemberFunctor2_T<O,T1,T2>* GlsFunctor(void (O::*f)(T1, T2))
{
    return new GlsStaticMemberFunctor2_T<O,T1,T2>(f);
}

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T1, class T2>
GlsMemberFunctor2_T<O,T1,T2>* GlsFunctor(O& o, void (O::*f)(T1, T2))
{
    return new GlsMemberFunctor2_T<O,T1,T2>(o, f);
}

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T1, class T2>
GlsConstMemberFunctor2_T<O,T1,T2>* GlsFunctor(const O& o, void (O::*f)(T1, T2) const)
{
    return new GlsConstMemberFunctor2_T<O,T1,T2>(o, f);
}


//----------------------------------------------------------------------------
//                         3 ARGUMENT FUNCTORS
//----------------------------------------------------------------------------
template <class T1, class T2, class T3>
class GlsFunctor3_T
{
public:
    virtual void operator()(T1 arg1, T2 arg2, T3 arg3) = 0;
};

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T1, class T2, class T3>
class GlsStaticMemberFunctor3_T : public GlsFunctor3_T<T1, T2, T3>
{
public:
    typedef void (O::*F)(T1, T2, T3);
    GlsStaticMemberFunctor3_T(F f) : _f(f) {}
    virtual void operator()(T1 arg1, T2 arg2, T3 arg3) { (*_f)(arg1, arg2, arg3); }
private:
    F  _f;
};

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T1, class T2, class T3>
class GlsMemberFunctor3_T : public GlsFunctor3_T<T1, T2, T3>
{
public:
    typedef void (O::*F)(T1, T2, T3);
    GlsMemberFunctor3_T(O& o, F f) : _o(o), _f(f) {}
    virtual void operator()(T1 arg1, T2 arg2, T3 arg3) { (_o.*_f)(arg1, arg2, arg3); }
private:
    O& _o;
    F  _f;
};

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T1, class T2, class T3>
class GlsConstMemberFunctor3_T : public GlsFunctor3_T<T1, T2, T3>
{
public:
    typedef void (O::*F)(T1, T2, T3) const;
    GlsConstMemberFunctor3_T(const O& o, F f) : _o(o), _f(f) {}
    virtual void operator()(T1 arg1, T2 arg2, T3 arg3) { (_o.*_f)(arg1, arg2, arg3); }
private:
    const O& _o;
    F  _f;
};

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T1, class T2, class T3>
GlsStaticMemberFunctor3_T<O,T1, T2, T3>* GlsFunctor(void (O::*f)(T1, T2, T3))
{
    return new GlsStaticMemberFunctor3_T<O,T1, T2, T3>(f);
}

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T1, class T2, class T3>
GlsMemberFunctor3_T<O,T1, T2, T3>* GlsFunctor(O& o, void (O::*f)(T1, T2, T3))
{
    return new GlsMemberFunctor3_T<O,T1, T2, T3>(o, f);
}

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
template <class O, class T1, class T2, class T3>
GlsConstMemberFunctor3_T<O,T1, T2, T3>* GlsFunctor(const O& o, void (O::*f)(T1, T2, T3) const)
{
    return new GlsConstMemberFunctor3_T<O,T1, T2, T3>(o, f);
}


#endif // GLS_FUNCTOR_H