FBB::FnWrap1c - Configurabale unary argument wrapper template class
SYNOPSIS
#include <bobcat/fnwrap1c>
DESCRIPTION
The FBB::FnWrap1c class is a configurable unary argument wrapper
template class. Its primary use is in combination with the generic algorithms
from the standard template libray. The called function expects a local
context struct which is used to pass arguments to the function called by the
generic algorithm which are available in the local context of the called
generic algorithm. The local context struct can be either a const or
non-const struct.
The called function itself may be specified as one of the constructor's
arguments. It must be a (static member) function. Using a (static member)
function has various advantages, especially with the FnWrap?c classes to
which a local context can be passed:
There is no introduced uncertainty about the const-ness of the
callled function, as static member functions do not support
a const modifier;
The passed function can also be a free (global) function to which a
local context is passed;
The passed function can be a static member function of the class
using the generic algorithm to which the FBB::FnWrap1c object is passed. By
passing the calling object in the function's local context, the function may
directly access the calling object's members.
The passed function can be a static member function of the class
whose objects are passed to the function via the generic template function s
iterator parameters. In that case the function may directly access the passed
object's members.
Since no object is involved in calling the static function, no
ambiguity can arise as to whether an object reference or an object pointer
should be used in calling the function: static (member) functions may be
called without using objects.
The FBB::FnWrap1c template class has the following template parameters:
Type: the type of the argument passed to FBB::FnWrap1c's
operator()() function. Specify the type as the type of the parameter of
the function whose address is passed to the constructor (i.e., specify a plain
value or a (const) pointer or reference).
Context: the local context struct. This struct is a local
struct, an object of which could have been defined immediatey before
applying the generic algorithm. The local context struct object may specify
values, references or pointers to entities that are available in the local
context where the generic algorithm is called.
If no generic algorithm would have been used, but a local implementation
of the generic algorithm would have been used instead, then the called
function would have received certain arguments. The local context struct is a
replacement of such a function's parameter list, mimicking the function's
parameter list in the struct definition. The function will now receive a
`standardized' parameter list, defined by the local context struct. The type
of the defined struct as specified in the parameterlist of the function
whose address is passed to FnWrap1c's constructor should be specified for
Context. E.g., LocalStruct &.
When a non-const reference or pointer is specified, the function may
modify the struct's value fields identically to the situation where the
field's values are passed to the function as reference parameters.
ReturnType: the ReturnType is by default defined as void. By
specifying another type, the FBB::FnWrap1c object's operator()()
function will return the called function's return value as a value of the
specified type. E.g, by specifying a boolReturnType, the
FBB::FnWrap1c object may be used as a Unary Predicate. Alternatively,
pointers or references may be specified as return values.
NAMESPACE
FBB
All constructors, members, operators and manipulators, mentioned in this
man-page, are defined in the namespace FBB.
This constructor expects two arguments: the address of a function to
call from within its operator()() member, and a local
context struct which is passed to the called function as its second
argument.
When the function pointed to by fun is called from
FBB::FnWrap1c::operator()(), it receives the latter function's
argument as its first argument and the local context struct as its second
argument. With (STL) generic algorithms the template parameter Type must
define the data type to which iterators (as specified in, e.g.,
std::for_each()) eventually point.
Hint: In situations where no context other than the class Class to
which the class' (static) member function belongs must be used `Class
&obj' (or a (const) pointer) can be specified as the context parameter,
passing, e.g., *this as the context. The static member function may then
call any of the non-static member functions of the class Class using the
normal syntax (e.g., obj.member(argument) if the static function defines
as its second parameter Class &obj).
OVERLOADED OPERATOR
The following member function will call the function
that's passed to FBB::FnWrap1c's constructor. See the example below.
ReturnType operator()(Type param) const:
This function is called by generic algorithms, receiving the
dereferenced iterator that is managed by the generic algorithm as its
argument (so, the iterator may points to modifiable Type objects). This
function calls the function specified at FBB::FnWrap1c's constructor,
passing its parameter value to that function as its first argument, and the
local context as its second argument.
TYPEDEFS
The class defines two types, which are used by generic algorithms:
argument_type: , a synonym for the basic type specified with the
Type template parameter. E.g., if Type is specified as std::string
const * then argument_type will be std::string;
result_type: , a synonym for the basic type specified with the
ReturnType template parameter.