| Home | Libraries | People | FAQ | More

## Struct template impl

boost::proto::call::impl

## Synopsis

    // In header: <boost/proto/transform/call.hpp>

    template<typename Expr, typename State, typename Data>
    struct impl :  proto::transform_impl<Expr, State, Data> {
      // types
      typedef see-below result_type;

      // public member functions
      result_type operator()(typename impl::expr_param,
                             typename impl::state_param,
                             typename impl::data_param) const;
    };

## Description

### `impl` public types

1. typedef `see-below` result_type;

   In the description that follows, a type `T` is determined to model the PrimitiveTransform concept if `proto::is_transform<T>::value` is `true`.

   `proto::call<T>::impl<Expr,State,Data>::result_type` is computed as follows:

   - If `T` if of the form `PrimitiveTransform` or `PrimitiveTransform()`, then `result_type` is:

         typename boost::result_of<PrimitiveTransform(Expr, State, Data)>::type

   - If `T` is of the form `PrimitiveTransform(A0)`, then `result_type` is:

         typename boost::result_of<PrimitiveTransform(
           typename boost::result_of<when<_,A0>(Expr, State, Data)>::type,
           State,
           Data
         )>::type

   - If `T` is of the form `PrimitiveTransform(A0, A1)`, then `result_type` is:

         typename boost::result_of<PrimitiveTransform(
           typename boost::result_of<when<_,A0>(Expr, State, Data)>::type,
           typename boost::result_of<when<_,A1>(Expr, State, Data)>::type,
           Data
         )>::type

   - If `T` is of the form `PrimitiveTransform(A0, A1, A2)`, then `result_type` is:

         typename boost::result_of<PrimitiveTransform(
           typename boost::result_of<when<_,A0>(Expr, State, Data)>::type,
           typename boost::result_of<when<_,A1>(Expr, State, Data)>::type,
           typename boost::result_of<when<_,A2>(Expr, State, Data)>::type
         )>::type

   - If `T` is of the form `PolymorphicFunctionObject(A0,…An)`, then `result_type` is:

         typename boost::result_of<PolymorphicFunctionObject(
           typename boost::result_of<when<_,A0>(Expr, State, Data)>::type,
           …
           typename boost::result_of<when<_,An>(Expr, State, Data)>::type
         >::type

   - If `T` is of the form `PolymorphicFunctionObject(A0,…An ...)`, then let `T'` be `PolymorphicFunctionObject(A0,…An-1, `S`)`, where `S` is a type sequence computed from the unpacking expression `An` as described in the reference for `proto::pack`. Then, `result_type` is:

         typename proto::call<T'>::impl<Expr,State,Data>::result_type

### `impl` public member functions

1.     result_type operator()(typename impl::expr_param expr,
                              typename impl::state_param state,
                              typename impl::data_param data) const;

   In the description that follows, a type `T` is determined to model the PrimitiveTransform concept if ``proto::is_transform`<T>::value` is `true`.

   ``proto::call`<T>::impl<Expr,State,Data>::operator()` behaves as follows:

   - If `T` if of the form `PrimitiveTransform` or `PrimitiveTransform()`, then return

         PrimitiveTransform()(expr, state, data)

   - If `T` is of the form `PrimitiveTransform(A0)`, then return

         PrimitiveTransform()(
           when<_,A0>()(expr, state, data),
           state,
           sata
         )

   - If `T` is of the form `PrimitiveTransform(A0, A1)`, then return:

         PrimitiveTransform()(
           when<_,A0>()(expr, state, data),
           when<_,A1>()(expr, state, data),
           Data
         )

   - If `T` is of the form `PrimitiveTransform(A0, A1, A2)`, then return

         PrimitiveTransform()(
           when<_,A0>()(expr, state, data),
           when<_,A1>()(expr, state, data),
           when<_,A2>()(expr, state, data)
         )

   - If `T` is of the form `PolymorphicFunctionObject(A0,…An)`, then return:

         PolymorphicFunctionObject()(
           when<_,A0>()(expr, state, data),
           ...
           when<_,An>()(expr, state, data)
         )

   - If `T` is of the form `PolymorphicFunctionObject(A0,…An ...)`, then let `T'` be `PolymorphicFunctionObject(A0,…An-1, `S`)`, where `S` is a type sequence computed from the unpacking expression `An` as described in the reference for ``proto::pack``. Then, return:

         proto::call<T'>()(expr, state, data)