Changes between Initial Version and Version 1 of code/doc/Functor

Timestamp:

Sep 30, 2008, 12:14:31 AM (16 years ago)

Author:

landauf

Comment:

—

code/doc/Functor

@@ +1 @@
+= Functor =
+[[TracNav(TracNav/TOC_Development)]]
+[[TOC]]
+
+== Description ==
+The Functor is a wrapper around a function-pointer. You can call the function by executing the Functor without taking care of the types of parameters and return value. This is achieved by using [wiki:MultiType] to pass arguments.
+
+Functor works with (almost) every function. This is possible because of a number of derived templates, one for every possible combination:
+ * Static, member or const member
+ * With or without returnvalue
+ * With or without parameters (up to five parameters are allowed)
+
+As you see, this results in a total amount of 3*2*6 = 36 combinations, each of them implemented as a template to allow arbitrary types for classes, returnvalues and parameters.
+
+Functor.h implements all those templates by using a macro to avoid annoying code repetition.
+
+'''Limitation''': Because Functor uses [wiki:MultiType] to pass the arguments, parameters and return values must be of a [wiki:MultiType# supported type].
+
+== Usage ==
+=== Creation ===
+To simplify creation of a new Functor, the helper function '''createFunctor('''''function-pointer''''')''' was created. Without that function, you would have to pick the right template (out of 36 possibilities) and specify all template arguments - quite annoying. But with '''createFunctor''' it's really easy:
+{{{
+int someFunction(float param1, bool param2);
+
+Functor* myFunctor = createFunctor(&someFunction);
+}}}
+In this case, ''&someFunction'' is the function-pointer of the static function "someFuncton". For memberfunctions, this looks a bit different:
+{{{
+class SomeClass
+{
+    float someFunction(const std::string& param);
+};
+
+Functor* myFunctor = createFunctor(&SomeClass::someFunction);
+}}}
+Remember: This is just basic function-pointer knowledge, nothing special here. Functor does what it has to do and createFunctor works as usual.
+
+'''Important''': createFunctor uses '''new''' to create the Functor and returns a pointer. If you are responsible for the pointer, you have to delete the Functor after usage.
+
+=== Call ===
+To call the function, just use operator() and pass the arguments as if you would call the function-pointer directly:
+{{{
+void someFunction(int value);
+Functor* myFunctor = createFunctor(&someFunction);
+
+(*myFunctor)(10); // equivalent to someFunction(10);
+}}}
+
+=== Returnvalue ===
+If your function returns a value, use '''getReturnvalue()''':
+{{{
+int doubleValue(int value) { return value*2; }
+Functor* myFunctor = createFunctor(&doubleValue);
+
+(*myFunctor)(10); // equivalent to doubleValue(10);
+
+int result = myFunctor->getReturnvalue(); // result = 20
+}}}
+
+=== Information ===
+There are some functions returning some information about the function:
+ * '''getParamCount()''': Returns the amount of parameters the function takes
+ * '''hasReturnvalue()''': Returns true if the function returns a value
+ * '''getType()''': Returns the type of the function as an enum: FT_MEMBER, FT_CONSTMEMBER, FT_STATIC
+ * '''getTypenameParam('''''param number (0-4)''''')''': Returns the typename of the given parameter as a string
+ * '''getTypenameReturnvalue()''': Returns the typename of the returnvalue as a string
+
+== Types ==
+=== FunctorStatic ===
+
+=== FunctorMember ===
+
+== Template ==
+
+== Examples ==