Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is an old version of boost. Click here for the latest version's documentation home page.
PrevUpHomeNext

unfused_generic

Description

An n-ary Polymorphic Function Object adapter template for an unary Polymorphic Function Object target function. When called, its arguments are bundled to a Random Access Sequence of references that is passed to the target function. Non-const LValue arguments are transported as references to non-const, otherwise references to const are used.

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 if the target function object is const - or, in case the target function object is held by value, the adapter is const).

/functional/adapter/unfused_generic.hpp>

Synopsis
template <class Function>
class unfused_generic;
Template parameters

Parameter

Description

Default

Function

An unary Polymorphic Function Object

Model of

Notation

F

A possibly const qualified, unary Polymorphic Function Object type or reference type thereof

f

An object convertible to F

UG

The type unfused_generic<F>

ug

An instance of UG, initialized with f

a0...aN

Arguments to ug

Expression Semantics

Expression

Semantics

UG(f)

Creates a fused function as described above, initializes the target function with f.

UG()

Creates a fused function as described above, attempts to use F's default constructor.

ug(a0...aN)

Calls f with a Sequence that contains references to the arguments a0...aN.

Example
template <typename Function, typename T>
class fused_bound_1st
{
    typename traits::deduce<Function>::type fnc_deferred;
    typename traits::deduce<T>::type        xxx_bound;
public:

    fused_bound_1st(Function deferred, T bound)
        : fnc_deferred(deferred), xxx_bound(bound)
    { }

    template <typename Sig>
    struct result;

    template <class Self, class Seq>
    struct result< Self(Seq) >
        : result_of::invoke< Function, typename result_of::push_front<
            typename remove_reference<Seq>::type, T>::type >
    { };

    template <class Seq>
    typename result< void(Seq) >::type operator()(Seq const & s) const
    {
        return invoke(fnc_deferred, push_front(s,xxx_bound));
    }
};

template <typename Function, typename T>
unfused_generic< fused_bound_1st<Function,T> >
bind_1st(Function f, T const & x)
{
    return unfused_generic< fused_bound_1st<Function,T> >(
        fused_bound_1st<Function,T>(f,x) );
}

int test_func(int a, int b, int c)
{
    return a+b+c;
}

void try_it()
{
    assert(bind_1st(& test_func,3)(-2,-1) == 0);
    assert(bind_1st(std::plus<float>(), 1)(0.5f) == 1.5f);
}
See also

PrevUpHomeNext