function_objects.hpp

Go to the documentation of this file.

 
/*****************************************************************************
** Ifdefs
*****************************************************************************/
 
#ifndef ECL_UTILITIES_FUNCTION_OBJECTS_HPP_
#define ECL_UTILITIES_FUNCTION_OBJECTS_HPP_
 
/*****************************************************************************
** Includes
*****************************************************************************/
 
#include <ecl/concepts/nullary_function.hpp>
#include "../utilities/references.hpp"
 
/*****************************************************************************
** Namespaces
*****************************************************************************/
 
namespace ecl {
 
/*****************************************************************************
** Using
*****************************************************************************/
 
/*****************************************************************************
** Interface [NullaryFunction]
*****************************************************************************/
template <typename R = void>
class NullaryFunction {
public:
        typedef R result_type;  
        virtual result_type operator()() = 0; 
        virtual ~NullaryFunction() {}; 
};
 
/*****************************************************************************
** Interface [UnaryFunction]
*****************************************************************************/
 
template <typename A, typename R = void>
class UnaryFunction {
public:
        typedef R result_type; 
        typedef A argument_type; 
        virtual result_type operator()(argument_type arg) = 0; 
        virtual ~UnaryFunction() {}; 
};
 
/*****************************************************************************
** Interface [BinaryFunction]
*****************************************************************************/
template <typename A1, typename A2, typename R = void>
class BinaryFunction {
public:
        typedef R result_type; 
        typedef A1 first_argument_type; 
        typedef A2 second_argument_type; 
        virtual result_type operator()(first_argument_type arg1, second_argument_type arg2) = 0; 
        virtual ~BinaryFunction() {}; 
};
 
/*****************************************************************************
** Interface [FreeFunctions]
*****************************************************************************/
template <typename R = void>
class NullaryFreeFunction : public NullaryFunction<R>
{
public:
        NullaryFreeFunction( R (*function)() ) : free_function(function) {}
        virtual ~NullaryFreeFunction() {}; 
        R operator()() { return free_function(); }
 
private:
        R (*free_function)();
};
 
template <>
class NullaryFreeFunction<void> : public NullaryFunction<void>
{
public:
        NullaryFreeFunction( void (*function)() ) : free_function(function) {}
 
        virtual ~NullaryFreeFunction() {}; 
        void operator()() { free_function(); }
 
private:
        void (*free_function)();
};
 
template <typename A, typename R = void>
class UnaryFreeFunction : public UnaryFunction<A,R>
{
public:
        UnaryFreeFunction( R (*function)(A) ) : free_function(function) {}
 
        virtual ~UnaryFreeFunction() {}; 
        R operator()(A a) { return free_function(a); }
 
private:
        R (*free_function)(A);
};
 
template <typename A>
class UnaryFreeFunction<A,void> : public UnaryFunction<A,void>
{
public:
        UnaryFreeFunction( void (*function)(A) ) : free_function(function) {}
 
        virtual ~UnaryFreeFunction() {}; 
        void operator()(A a) { free_function(a); }
 
private:
        void (*free_function)(A);
};
 
/*****************************************************************************
** Interface [BoundFreeFunctions]
*****************************************************************************/
template <typename A, typename R = void>
class BoundUnaryFreeFunction : public NullaryFunction<R>
{
public:
        BoundUnaryFreeFunction( R (*function)(A), A a ) : free_function(function), argument(a) {}
        virtual ~BoundUnaryFreeFunction() {}; 
        R operator()() { return free_function(argument); }
 
private:
        R (*free_function)(A);
        A argument;
};
 
template <typename A>
class BoundUnaryFreeFunction<A,void> : public NullaryFunction<void>
{
public:
        BoundUnaryFreeFunction( void (*function)(A), A a ) : free_function(function), argument(a) {}
        virtual ~BoundUnaryFreeFunction() {}; 
        void operator()() { free_function(argument); }
 
private:
        void (*free_function)(A);
        A argument;
};
 
/*****************************************************************************
 * Interface [MemberFunctions]
 *****************************************************************************
 * Could make copies+refs here, just like mem_fun and mem_fun_ref but I can't
 * see the need for copy style setups.
 ****************************************************************************/
 
template <typename C, typename R = void>
class NullaryMemberFunction  : public UnaryFunction<C&,R> {
public:
        NullaryMemberFunction( R (C::*function)()) : member_function(function) {}
        virtual ~NullaryMemberFunction() {}; 
        R operator()(C &class_object) {
                return (class_object.*member_function)();
        }
private:
    R (C::*member_function)();
};
 
template <typename C>
class NullaryMemberFunction<C,void>  : public UnaryFunction<C&,void> {
public:
        NullaryMemberFunction( void (C::*function)()) : member_function(function) {}
        virtual ~NullaryMemberFunction() {}; 
        void operator()(C &class_object) {
                (class_object.*member_function)();
        }
private:
    void (C::*member_function)();
};
 
template <typename C, typename A, typename R = void>
class UnaryMemberFunction  : public BinaryFunction<C&,A,R> {
public:
        UnaryMemberFunction( R (C::*function)(A)) : member_function(function) {}
        virtual ~UnaryMemberFunction() {}; 
        R operator()(C &class_object, A a) {
                return (class_object.*member_function)(a);
        }
private:
    R (C::*member_function)(A);
};
 
template <typename C, typename A>
class UnaryMemberFunction<C,A,void>  : public BinaryFunction<C&,A,void> {
public:
        UnaryMemberFunction( void (C::*function)(A)) : member_function(function) {}
        virtual ~UnaryMemberFunction() {}; 
        void operator()(C &class_object, A a) {
                (class_object.*member_function)(a);
        }
private:
    void (C::*member_function)(A);
};
 
/*****************************************************************************
** Interface [BoundMemberFunctions]
*****************************************************************************/
 
template <typename C, typename R = void>
class BoundNullaryMemberFunction : public NullaryFunction<R> {
public:
        BoundNullaryMemberFunction( R (C::*function)(), C &class_object) :
                member_class(class_object),
                member_function(function)
        {}
        virtual ~BoundNullaryMemberFunction() {}; 
        R operator()() { return (member_class.*member_function)(); }
 
private:
        C &member_class;
    R (C::*member_function)();
};
 
template <typename C>
class BoundNullaryMemberFunction<C,void> : public NullaryFunction<void> {
public:
        BoundNullaryMemberFunction( void (C::*function)(), C &class_object) :
                member_class(class_object),
                member_function(function)
        {}
 
        virtual ~BoundNullaryMemberFunction() {}; 
        void operator()() { (member_class.*member_function)(); }
 
private:
        C &member_class;
    void (C::*member_function)();
};
 
template <typename C, typename A, typename R = void>
class PartiallyBoundUnaryMemberFunction : public UnaryFunction<A,R> {
public:
        PartiallyBoundUnaryMemberFunction( R (C::*function)(A), C &class_object) :
                member_class(class_object),
                member_function(function)
        {}
        virtual ~PartiallyBoundUnaryMemberFunction() {}; 
        R operator()(A a) {
                return (member_class.*member_function)(a);
        }
private:
        C &member_class;
    void (C::*member_function)(A);
};
template <typename C, typename A, typename R = void>
class BoundUnaryMemberFunction : public NullaryFunction<R> {
public:
        BoundUnaryMemberFunction( R (C::*function)(A), C &class_object, A a) :
                member_class(class_object),
                member_function(function),
                argument(a)
        {}
        virtual ~BoundUnaryMemberFunction() {}; 
        R operator()() {
                return (member_class.*member_function)(argument);
        }
private:
        C &member_class;
    void (C::*member_function)(A);
    A argument;
};
 
template <typename C, typename A, typename B, typename R = void>
class PartiallyBoundBinaryMemberFunction : public BinaryFunction<A,B,R> {
public:
        PartiallyBoundBinaryMemberFunction( R (C::*function)(A, B), C &class_object) :
                member_class(class_object),
                member_function(function)
        {}
        virtual ~PartiallyBoundBinaryMemberFunction() {}; 
        R operator()(A a, B b) {
                return (member_class.*member_function)(a, b);
        }
private:
        C &member_class;
        void (C::*member_function)(A, B);
};
/*****************************************************************************
** Function Object Wrappers
*****************************************************************************/
template <typename FunctionObject, typename Result = void>
class NullaryFunctionCopy : public NullaryFunction<Result>
{
public:
        NullaryFunctionCopy(const FunctionObject &f_o ) : function_object(f_o) {
                ecl_compile_time_concept_check(NullaryFunction<FunctionObject>);
        }
        virtual ~NullaryFunctionCopy() {}; 
        Result operator()() { return function_object(); }
 
private:
        FunctionObject function_object;
};
 
template <typename FunctionObject>
class NullaryFunctionCopy<FunctionObject,void> : public NullaryFunction<void>
{
public:
        explicit NullaryFunctionCopy( const FunctionObject &f_o ) : function_object(f_o) {
                ecl_compile_time_concept_check(NullaryFunction<FunctionObject>);
        }
        virtual ~NullaryFunctionCopy() {}; 
        void operator()() { function_object(); }
 
private:
        FunctionObject function_object;
};
 
template <typename FunctionObject, typename Result = void>
class NullaryFunctionReference : public NullaryFunction<Result>
{
public:
        explicit NullaryFunctionReference( const ReferenceWrapper<FunctionObject> &wrapper ) : function_object(wrapper.reference()) {
                ecl_compile_time_concept_check(NullaryFunction<FunctionObject>);
        }
        virtual ~NullaryFunctionReference() {}; 
        Result operator()() { return function_object(); }
 
private:
        FunctionObject &function_object;
};
 
template <typename FunctionObject>
class NullaryFunctionReference< FunctionObject, void > : public NullaryFunction<void>
{
public:
        explicit NullaryFunctionReference( const ReferenceWrapper<FunctionObject> &wrapper ) : function_object(wrapper.reference()) {
                ecl_compile_time_concept_check(NullaryFunction<FunctionObject>);
        }
        virtual ~NullaryFunctionReference() {}; 
        void operator()() { function_object(); }
 
private:
        FunctionObject &function_object;
};
 
template <typename FunctionObject, typename T, typename Result = void>
class UnaryFunctionCopy : public UnaryFunction<T, Result>
{
public:
        UnaryFunctionCopy(const FunctionObject &f_o ) : function_object(f_o) {
//              ecl_compile_time_concept_check(UnaryFunction<FunctionObject>);
        }
        virtual ~UnaryFunctionCopy() {}; 
        Result operator()(T t) { return function_object(t); }
 
private:
        FunctionObject function_object;
};
 
template <typename FunctionObject, typename T>
class UnaryFunctionCopy<FunctionObject,T,void> : public UnaryFunction<T, void>
{
public:
        explicit UnaryFunctionCopy( const FunctionObject &f_o ) : function_object(f_o) {
//              ecl_compile_time_concept_check(UnaryFunction<FunctionObject>);
        }
        virtual ~UnaryFunctionCopy() {}; 
        void operator()(T t) { function_object(t); }
 
private:
        FunctionObject function_object;
};
 
template <typename FunctionObject, typename T, typename Result = void>
class UnaryFunctionReference : public UnaryFunction<T, Result>
{
public:
        explicit UnaryFunctionReference( const ReferenceWrapper<FunctionObject> &wrapper ) : function_object(wrapper.reference()) {
//              ecl_compile_time_concept_check(UnaryFunction<FunctionObject>);
        }
 
        virtual ~UnaryFunctionReference() {}; 
        Result operator()(T t) { return function_object(t); }
 
private:
        FunctionObject &function_object;
};
 
template <typename ReferenceWrapper, typename T>
class UnaryFunctionReference< ReferenceWrapper, T, void > : public UnaryFunction<T,void>
{
public:
        typedef typename ReferenceWrapper::type FunctionObject; 
        explicit UnaryFunctionReference( const ReferenceWrapper &wrapper ) : function_object(wrapper.reference()) {
//              ecl_compile_time_concept_check(UnaryFunction<FunctionObject>);
        }
        virtual ~UnaryFunctionReference() {}; 
        void operator()(T t) { function_object(t); }
 
private:
        FunctionObject &function_object;
};
 
/*****************************************************************************
** Nullary Function Generators
*****************************************************************************/
 
template <typename R>
NullaryFreeFunction<R> generateFunctionObject( R (*function)() ) {
        return NullaryFreeFunction<R>( function );
}
 
template <typename A, typename R>
UnaryFreeFunction<A,R> generateFunctionObject( R (*function)(A) ) {
        return UnaryFreeFunction<A,R>( function );
}
 
template <typename A, typename R, typename I>
BoundUnaryFreeFunction<A,R> generateFunctionObject( R (*function)(A), I& a ) {
        return BoundUnaryFreeFunction<A,R>( function, a );
}
 
template <typename A, typename R, typename I>
BoundUnaryFreeFunction<A,R> generateFunctionObject( R (*function)(A), const I& a ) {
        return BoundUnaryFreeFunction<A,R>( function, a );
}
 
template <typename C, typename R>
NullaryMemberFunction<C,R> generateFunctionObject( R (C::*function)() ) {
        return NullaryMemberFunction<C,R>( function );
}
 
template <typename C, typename R>
BoundNullaryMemberFunction<C,R> generateFunctionObject( R (C::*function)(), C &c ) {
        return BoundNullaryMemberFunction<C,R>( function, c );
}
 
template <typename C, typename A, typename R>
UnaryMemberFunction<C,A,R> generateFunctionObject( R (C::*function)(A) ) {
        return UnaryMemberFunction<C,A,R>( function );
}
 
template <typename C, typename A, typename R>
PartiallyBoundUnaryMemberFunction<C,A,R> generateFunctionObject( R (C::*function)(A), C& c) {
        return PartiallyBoundUnaryMemberFunction<C,A,R>( function, c);
}
 
template <typename C, typename A, typename R, typename I>
BoundUnaryMemberFunction<C,A,R> generateFunctionObject( R (C::*function)(A), C& c, I& a ) {
        // The I here is a bit of a trick...if you use A in the constructor above instead of I
        // then it gets confused trying to deduce A as often the function arg and the input value
        // are different types (e.g. const int& as opposed to int). So fix A in the template
        // direction first, then pass it a type I which can be converted on the fly where needed.
        return BoundUnaryMemberFunction<C,A,R>( function, c, a );
}
 
template <typename C, typename A, typename R, typename I>
BoundUnaryMemberFunction<C,A,R> generateFunctionObject( R (C::*function)(A), C& c, const I& a ) {
        // This one differs from the previous due to the const reference - this allows things like
        // temporaries to pass through unscathed to a function with an argument like const int&.
        return BoundUnaryMemberFunction<C,A,R>( function, c, a );
}
 
}; // namespace ecl
 
#endif /* ECL_UTILITIES_FUNCTION_OBJECTS_HPP_ */