libbobcat1-dev_2.08.01-x.tar.gz Configurable Function Wrapper
2005-2010
NAME
FnWrap - Generic configurable context function wrapper class
SYNOPSIS
#include <bobcat/fnwrap>
DESCRIPTION
The FBB::FnWrap class contains two static members: unary and
binary. The unary function returns a unary functor that is ordinarily
called from generic algorithms of the standard template libray expecting a
unary functor or predicate. The binary function returns a binary functor
that is ordinarily called from generic algorithms of the standard template
libray expecting a binary functor or predicate.
The unary and binary functions expect the name of a (static or free)
function that will be called from the functor's function operator. The
arguments received by the functor's function operator are forwarded to the
static or free function that is called by the functor's function operator.
Any additional arguments that are passed to unary or binary are
forwarded to the function that is called by the functor's function
operator. This allows users of FnWrap to pass a local context to the
function that is indirectly called by a generic algorithm.
The number and types of arguments are determined by the parameter list of the
function that is called by the functor's function operator. If that former
function, in addition to parameters matching the types of the arguments
provided by the generic algorithm also defines, e.g., an int and
std::string & parameter then the FnWrap member functions must be
called with the address of the function to call, with an int argument and
with a std::stringlvalue.
The type of the return value of the function whose address is passed to the
FnWrap members will be the return type of the functor's function call
operator. So if the generic algorithm expects a predicate function the
function called by the functor's function call operator should return a
bool value.
The called function must be a static member or free function. Using a static
member or free function has several advantages over calling a non-static
class member function:
No object for which the member function will be called needs to be
provided;
There is no introduced uncertainty about the const-ness of the
callled function, as static member functions and free functions do not support
const modifiers;
The called function can be a static member function of the class
using the generic algorithm to which the FnWrap object is passed. By
specifying the calling object as one of the arguments of the FnWrap
function, the called function will receive this object as well and 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.
NAMESPACE
FBB
All constructors, members, operators and manipulators, mentioned in this
man-page, are defined in the namespace FBB.
INHERITS FROM
-
STATIC MEMBERS
Functor unary(Function [, Arguments]): Functor represents the (unary) functor that can be used by generic
algorithms; Function is the name of a static member or free function that will
be called from the Functor's function operator. The type of its
first argument must match the type of the argument received by the functor's
function call operator. Any additional types must match, in type and number,
the additional arguments that are passed to unary. Function's return
type will be the return type of Functor's function call operator. If a
value is returned by Function it will be returned by Functor's
function call operator.
Functor binary(Function [, Arguments]): Functor represents the (binary) functor that can be used by
generic algorithms; Function is the name of a static member or free function that will
be called from the Functor's function operator. The types of its first two
arguments must match the types of the first two arguments received by the
functor's function call operator. Any additional types must match, in type and
number, the additional arguments that are passed to binary. Function's
return type will be the return type of Functor's function call
operator. If a value is returned by Function it will be returned by
Functor's function call operator.
TYPEDEFS
The functors defines types, that are used by generic algorithms:
first_argument_type: , a synonym for the basic type of the argument
received by the unary functor's function call operator and of the first
argument received by the binary functor's function call operator. E.g., if
the actual type is std::string const * then argument_type will
be std::string;
second_argument_type: , a synonym for the basic type of the second
argument received by the binary functor's function call operator.
result_type: , a synonym for the basic type of the return type of the
functor's function call operator.