fused_procedure

Description

An unary Polymorphic Function Object adapter template for Callable Object target functions. It takes a Forward Sequence that contains the arguments for the target function.

The result is discared and the adapter's return type is void. The nested result metafunction does not define a type member for target functions of non-class type whose arity is not satisfied by the size of the sequence.

The type of the target function is allowed to be const qualified or a reference. Const qualification is preserved and propagated appropriately (in other words, only const versions of operator() can be used for an target function object that is const or, if the target function object is held by value, the adapter is const - these semantics have nothing to do with the const qualification of a member function, which is referring to the type of object pointed to by this, which is specified with the first element in the sequence passed to the adapter).

If the target function is a pointer to a members function, the corresponding object can be specified as a reference, pointer, or smart pointer. In case of the latter, a freestanding get_pointer function must be defined (Boost provides this function for std::auto_ptr and boost::shared_ptr).

The target function must not be a pointer to a member object (dereferencing such a pointer without returning anything does not make sense, so it isn't implemented).

Header

#include <boost/fusion/functional/adapter/fused_procedure.hpp>

Synopsis

template <typename Function>
class fused_procedure;

Template parameters

Parameter	Description	Default
`Function`	Callable Object type

Model of

Notation

R: A possibly const qualified Callable Object type or reference type thereof
r: An object convertible to R
s: A Sequence of arguments that are accepted by r
f: An instance of fused<R>

Expression Semantics

Expression	Semantics
`fused_procedure<R>(r)`	Creates a fused function as described above, initializes the target function with `r`.
`fused_procedure<R>()`	Creates a fused function as described above, attempts to use `R`'s default constructor.
`f(s)`	Calls `r` with the elements in `s` as its arguments.

Example

template<class SequenceOfSequences, class Func>
void n_ary_for_each(SequenceOfSequences const & s, Func const & f)
{
    for_each(zip_view<SequenceOfSequences>(s), 
        fused_procedure<Func const &>(f));
} 

void try_it()
{
    vector<int,float> a(2,2.0f);
    vector<int,float> b(1,1.5f);
    using namespace boost::lambda;
    n_ary_for_each(vector_tie(a,b), _1 -= _2);
    assert(a == make_vector(1,0.5f));
}