From 68f41290a30001d3d05c8ccf4e2cf65bd8e740be Mon Sep 17 00:00:00 2001 From: Johannes Schickel Date: Tue, 29 Jul 2008 20:09:30 +0000 Subject: Documentation for func.h. svn-id: r33425 --- common/func.h | 119 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 119 insertions(+) (limited to 'common/func.h') diff --git a/common/func.h b/common/func.h index 95df96123a..fdb55b43c2 100644 --- a/common/func.h +++ b/common/func.h @@ -29,12 +29,18 @@ namespace Common { +/** + * Generic unary function. + */ template struct UnaryFunction { typedef Arg ArgumenType; typedef Result ResultType; }; +/** + * Generic binary function. + */ template struct BinaryFunction { typedef Arg1 FirstArgumentType; @@ -42,16 +48,25 @@ struct BinaryFunction { typedef Result ResultType; }; +/** + * Predicate to check for equallity of two data elements. + */ template struct EqualTo : public BinaryFunction { bool operator()(const T &x, const T &y) const { return x == y; } }; +/** + * Predicate to check for x being less than y. + */ template struct Less : public BinaryFunction { bool operator()(const T &x, const T &y) const { return x < y; } }; +/** + * Predicate to check for x being greater than y. + */ template struct Greater : public BinaryFunction { bool operator()(const T &x, const T &y) const { return x > y; } @@ -70,6 +85,10 @@ public: } }; +/** + * Transforms a binary function object into an unary function object. + * To achieve that the first parameter is bound to the passed value t. + */ template inline Binder1st bind1st(const Op &op, const T &t) { return Binder1st(op, t); @@ -88,6 +107,10 @@ public: } }; +/** + * Transforms a binary function object into an unary function object. + * To achieve that the second parameter is bound to the passed value t. + */ template inline Binder2nd bind2nd(const Op &op, const T &t) { return Binder2nd(op, t); @@ -119,11 +142,17 @@ public: } }; +/** + * Creates an unary function object from a function pointer. + */ template inline PointerToUnaryFunc ptr_fun(Result (*func)(Arg)) { return PointerToUnaryFunc(func); } +/** + * Creates an binary function object from a function pointer. + */ template inline PointerToBinaryFunc ptr_fun(Result (*func)(Arg1, Arg2)) { return PointerToBinaryFunc(func); @@ -181,21 +210,43 @@ public: } }; +/** + * Creates a unary function object from a class member function pointer. + * The parameter passed to the function object is the 'this' pointer to + * be used for the function call. + */ template inline MemFunc0 mem_fun(Result (T::*f)()) { return MemFunc0(f); } +/** + * Creates a unary function object from a class member function pointer. + * The parameter passed to the function object is the 'this' pointer to + * be used for the function call. + */ template inline ConstMemFunc0 mem_fun(Result (T::*f)() const) { return ConstMemFunc0(f); } +/** + * Creates a binary function object from a class member function pointer. + * The first parameter passed to the function object is the 'this' pointer to + * be used for the function call. + * The second one is the parameter passed to the member function. + */ template inline MemFunc1 mem_fun(Result (T::*f)(Arg)) { return MemFunc1(f); } +/** + * Creates a binary function object from a class member function pointer. + * The first parameter passed to the function object is the 'this' pointer to + * be used for the function call. + * The second one is the parameter passed to the member function. + */ template inline ConstMemFunc1 mem_fun(Result (T::*f)(Arg) const) { return ConstMemFunc1(f); @@ -203,6 +254,11 @@ inline ConstMemFunc1 mem_fun(Result (T::*f)(Arg) const) { // functor code +/** + * Generic functor object for function objects without parameters. + * + * @see Functor1 + */ template struct Functor0 { virtual ~Functor0() {} @@ -211,6 +267,18 @@ struct Functor0 { virtual Res operator()() const = 0; }; +/** + * Functor object for a class member function without parameter. + * + * Example creation: + * + * Foo bar; + * Functor0Men myFunctor(&bar, &Foo::myFunc); + * + * Example usage: + * + * myFunctor(); + */ template class Functor0Mem : public Functor0 { public: @@ -227,6 +295,38 @@ private: const FuncType _func; }; +/** + * Generic functor object for unary function objects. + * + * A typical usage for an unary function object is for executing opcodes + * in a script interpreter. To achieve that one can create an Common::Array + * object with 'Functor1 *' as type. Now after the right engine version + * has been determined and the opcode table to use is found one could easily + * add the opcode implementations like this: + * + * Common::Array *> opcodeTable; + * opcodeTable[0] = new Functor1Mem(&myEngine, &MyEngine_v1::o1_foo); + * opcodeTable[1] = new Functor1Mem(&myEngine, &MyEngine_v2::o2_foo); + * // unimplemented/unused opcode + * opcodeTable[2] = 0; + * etc. + * + * This makes it easy to add member functions of different classes as + * opcode functions to the function table. Since with the generic + * Functor1 object the only requirement for an + * function to be used is 'ScriptState' as argument and 'void' as return + * value. + * + * Now for calling the opcodes one has simple to do: + * if (opcodeTable[opcodeNum] && opcodeTable[opcodeNum]->isValid()) + * (*opcodeTable[opcodeNum])(scriptState); + * else + * warning("Unimplemented opcode %d", opcodeNum); + * + * If you want to see an real world example check the kyra engine. + * Files: engines/kyra/script.cpp and .h and engine/kyra/script_*.cpp + * are interesting for that matter. + */ template struct Functor1 : public Common::UnaryFunction { virtual ~Functor1() {} @@ -235,6 +335,13 @@ struct Functor1 : public Common::UnaryFunction { virtual Res operator()(Arg) const = 0; }; +/** + * Functor object for an unary class member function. + * Usage is like with Functor0Mem. The resulting functor object + * will take one parameter though. + * + * @see Functor0Men + */ template class Functor1Mem : public Functor1 { public: @@ -251,6 +358,11 @@ private: const FuncType _func; }; +/** + * Generic functor object for binary function objects. + * + * @see Functor1 + */ template struct Functor2 : public Common::BinaryFunction { virtual ~Functor2() {} @@ -259,6 +371,13 @@ struct Functor2 : public Common::BinaryFunction { virtual Res operator()(Arg1, Arg2) const = 0; }; +/** + * Functor object for a binary class member function. + * Usage is like with Functor0Mem. The resulting functor object + * will take two parameter though. + * + * @see Functor0Men + */ template class Functor2Mem : public Functor2 { public: -- cgit v1.2.3 From e3a600b1d0e9bb6f3932c338f12ffa7c74fef323 Mon Sep 17 00:00:00 2001 From: Johannes Schickel Date: Tue, 29 Jul 2008 20:15:29 +0000 Subject: Little fix for documentation. svn-id: r33426 --- common/func.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'common/func.h') diff --git a/common/func.h b/common/func.h index fdb55b43c2..83ef9758df 100644 --- a/common/func.h +++ b/common/func.h @@ -305,8 +305,8 @@ private: * add the opcode implementations like this: * * Common::Array *> opcodeTable; - * opcodeTable[0] = new Functor1Mem(&myEngine, &MyEngine_v1::o1_foo); - * opcodeTable[1] = new Functor1Mem(&myEngine, &MyEngine_v2::o2_foo); + * opcodeTable[0] = new Functor1Mem(&myEngine, &MyEngine_v1::o1_foo); + * opcodeTable[1] = new Functor1Mem(&myEngine, &MyEngine_v2::o2_foo); * // unimplemented/unused opcode * opcodeTable[2] = 0; * etc. -- cgit v1.2.3 From ca8a4eff265debb0aed9b038cc454be20cbe16e7 Mon Sep 17 00:00:00 2001 From: Johannes Schickel Date: Tue, 29 Jul 2008 20:21:54 +0000 Subject: - Formatting - Improved Functor#Mem::isValid implementations. svn-id: r33427 --- common/func.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'common/func.h') diff --git a/common/func.h b/common/func.h index 83ef9758df..1c045b9e5d 100644 --- a/common/func.h +++ b/common/func.h @@ -172,7 +172,7 @@ public: }; template -class ConstMemFunc0 : public UnaryFunction { +class ConstMemFunc0 : public UnaryFunction { private: Result (T::*_func)() const; public: @@ -185,7 +185,7 @@ public: }; template -class MemFunc1 : public BinaryFunction { +class MemFunc1 : public BinaryFunction { private: Result (T::*_func)(Arg); public: @@ -198,7 +198,7 @@ public: }; template -class ConstMemFunc1 : public BinaryFunction { +class ConstMemFunc1 : public BinaryFunction { private: Result (T::*_func)(Arg) const; public: @@ -286,7 +286,7 @@ public: Functor0Mem(T *t, const FuncType &func) : _t(t), _func(func) {} - bool isValid() const { return _func != 0; } + bool isValid() const { return _func != 0 && _t != 0; } Res operator()() const { return (_t->*_func)(); } @@ -349,7 +349,7 @@ public: Functor1Mem(T *t, const FuncType &func) : _t(t), _func(func) {} - bool isValid() const { return _func != 0; } + bool isValid() const { return _func != 0 && _t != 0; } Res operator()(Arg v1) const { return (_t->*_func)(v1); } @@ -385,7 +385,7 @@ public: Functor2Mem(T *t, const FuncType &func) : _t(t), _func(func) {} - bool isValid() const { return _func != 0; } + bool isValid() const { return _func != 0 && _t != 0; } Res operator()(Arg1 v1, Arg2 v2) const { return (_t->*_func)(v1, v2); } -- cgit v1.2.3