| Home | Libraries | People | FAQ | More

## Function call

boost::type_erasure::call

## Synopsis

    // In header: <boost/type_erasure/call.hpp>

    template<typename Concept, typename Op, class... U>
      unspecified call(const binding< Concept > & binding, const Op &,
                       U &&... args);
    template<typename Op, class... U> unspecified call(const Op &, U &&... args);

## Description

Dispatches a type erased function.

`Op` must be a primitive concept which is present in `Concept`. Its signature determines how the arguments of `call` are handled. If the argument is a `placeholder`, `call` expects an `any` using that `placeholder`. This `any` is unwrapped by `call`. The type that it stores must be the same type specified by `binding`. Any arguments that are not placeholders in the signature of `Op` are passed through unchanged.

If `binding` is not specified, it will be deduced from the arguments. Naturally this requires at least one argument to be an `any`. In this case, all `any` arguments must have the same `binding`.

Example:

     typedef mpl::vector<
       copy_constructible<_b>,
       addable<_a, int, _b> > concept;
     any<concept, _a> a = ...;
     any<concept, _b> b(call(addable<_a, int, _b>(), a, 10));

The signature of `addable` is `_b(const _a&, const int&)`

Returns: | The result of the operation. If the result type of the signature of `Op` is a placeholder, the result will be converted to the appropriate any type.
Throws: | bad_function_call if relaxed is in `Concept` and there is a type mismatch.