Overview
Examples
Screenshots
Comparisons
Applications
Download
Documentation
Tutorials
Bazaar
Status & Roadmap
FAQ
Authors & License
Forums
Funding Ultimate++
Search on this site











SourceForge.net Logo

Function

 

template <typename Res, typename... ArgTypes>

class Function<Res(ArgTypes...)> private Moveable<Function<Res(ArgTypes...)>> 

Upp::Function is wrapper to represent callable operation. It is similar to std::function with two differences:

Calling empty Function is allowed (and NOP). Returns zero.

Functions can be combined (chained) using operator<<.

 

Public Method List

 

Function()

Function(const Nuller&)

Creates empty Function. Invoking empty function is NOP and eventual return value is Res() (which results in 0 for fundamental types). Variant with Nuller is useful when defining function declaration with optional Function parameters like void Foo(Function<void ()> = Null);

 


 

template <class FFunction(F fn)

This is the 'catch lambda' constructor which allows converting generic lambda to Function value.

 


 

Function(const Function& src)

Function& operator=(const Function& src)

Function(Function&& src)

Function& operator=(Function&& src)

Usual copy/move constructors and assignment operators.

 


 

Function Proxy() const

Returns a new Function, which, when invoked, invokes this Function. This is useful when some Function is to changed later, but we need another Function to represent it.

 


 

template <class F> Function& operator<<(F fn)

Function& operator<<(const Function& fn)

Function& operator<<(Function&& fn)

These operators combine two Functions or function with lambda. Original 'this' function is invoked first and then fn. If either of Functions returns value, value of fn (argument to the right of <<) represents the value of whole Function.

 


 

Res operator()(ArgTypes... args) const

Performs the Functions.

 


 

operator bool() const

Returns true if Function is not empty.

 


 

void Clear()

Sets Function empty.

 

 

Event and Gate

 

Two most common types of Function in U++ are those that return 'void' and those that return 'bool'. U++ defines two convenience template aliases:

 

template <typename... ArgTypes> using Event = Function<void (ArgTypes...)>

Creates alias for Function returning void. For example, Event<int, String> is equivalent of Function<void (int, String)>.

 


 

template <typename... ArgTypes> using Gate = Function<bool (ArgTypes...)>

Creates alias for Function returning bool. For example, Gate<int, String> is equivalent of Function<bool (int, String)>.

 

 

MemFn and THISFN

 

 

Despide the power of C++11, there are still situations where it is better to put the callable code into member function. C++11 lamda syntax can be tedious in that case. MemFn template function and THISFN serve to reduce typing overhead.

 

template <class Ptr, class Class, class Res, class... ArgTypesEvent<ArgTypes...MemFn(Ptr object, Res (Class::*member_function)(ArgTypes...))

Equivalent of std::mem_fn returning U++ Function. Creates Function that represents calling member_function of instance object.

 


 

THISFN(x)

This macro is defined a MemFn(this, &CLASSNAME::x).

 

 

Last edit by cxl on 10/11/2017. Do you want to contribute?. T++