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