int main()
{
CallbackClass cb;
// For functors with no arguments:
std::list<ArFunctor*> functors;
ArFunctorC<CallbackClass> functor1(cb, &CallbackClass::callback1);
functors.push_back(&functor1);
functors.push_back(&functor1);
functors.push_back(&functor1);
std::for_each(functors.begin(), functors.end(),
std::mem_fun(&ArFunctor::invoke));
// For functors with arguments, give mem_fun template parameters.
std::list<ArFunctor1<int>*> functorsWithArg;
ArFunctor1C<CallbackClass, int> functor2(cb, &CallbackClass::callback2);
std::mem_fun1_t<void, ArFunctor1<int>, int> f(&ArFunctor1<int>::invoke);
functorsWithArg.push_back(&functor2);
functorsWithArg.push_back(&functor2);
functorsWithArg.push_back(&functor2);
std::for_each(functorsWithArg.begin(), functorsWithArg.end(), std::bind2nd(f, 42));
// You can use other STL algorithms if your functor returns something.
// count_if will invoke each functor, and return the number of functor
// invocations that returned true (in this case, 3, since they will
// always return true)
std::list<ArRetFunctor1<bool, const char*>*> functorsWithRet;
ArRetFunctor1C<bool, CallbackClass, const char *>
functor3(cb, &CallbackClass::callback3);
std::mem_fun1_t<bool, ArRetFunctor1<bool, const char*>, const char*> rf(&ArRetFunctor1<bool, const char*>::invokeR);
functorsWithRet.push_back(&functor3);
functorsWithRet.push_back(&functor3);
functorsWithRet.push_back(&functor3);
int c = std::count_if(functorsWithRet.begin(), functorsWithRet.end(), std::bind2nd(rf, "testing"));
std::cout << "Count=" << c << std::endl;
return(0);
}
int main()
{
CallbackContainer cb;
DriverClass driver;
ArFunctorC<CallbackContainer> functor1(cb, &CallbackContainer::callback1);
ArFunctor1C<CallbackContainer, int> functor2(cb, &CallbackContainer::callback2);
ArRetFunctor1C<bool, CallbackContainer, const char *>
functor3(cb, &CallbackContainer::callback3);
driver.setCallback1(&functor1);
driver.setCallback2(&functor2);
driver.setCallback3(&functor3);
driver.invokeFunctors();
/* You can make functors that target global functions too. */
ArGlobalFunctor globalFunctor(&globalCallback);
printf("Invoking globalFunctor... ");
globalFunctor.invoke();
/* You can also include the values of arguments in an ArFunctor object, if you
* want to use the same value in every invocation of the functor.
*/
ArFunctor1C<CallbackContainer, int> functor4(cb, &CallbackContainer::callback2, 42);
printf("Invoking functor with constant argument... ");
functor4.invoke();
/* Functors can be downcast to parent interface classes, as long as their invocation
* does not require arguments.
*/
ArFunctor* baseFunctor = &functor4;
printf("Invoking downcast functor... ");
baseFunctor->invoke();
return(0);
}
int main()
{
/* etape 2 */
std::cout << "TEST operator =" << std::endl;
Function<int (const char*)> functor;
functor = &myTest;
functor("test operator = : SUCCESS");
std::cout << "TEST constructor with assignation" << std::endl;
Function<int (const char*)> functor2 = &myTest;
functor("test constructor with assignation : SUCCESS");
std::cout << "TEST callable object" << std::endl;
Callable1 call1;
Function<void (char)> functor3 = &call1;
functor3('a');
std::cout << "TEST boost::bind with function" << std::endl;
Function<int (char)> functor4 = (boost::function<int (char)>)boost::bind(&boost_test, 'c');
functor4('a');
return 0;
}
