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

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(A₀), then result_type is:

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

If T is of the form PrimitiveTransform(A₀, A₁), then result_type is:

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

If T is of the form PrimitiveTransform(A₀, A₁, A₂), then result_type is:

typename boost::result_of<PrimitiveTransform(
  typename boost::result_of<when<_,A₀>(Expr, State, Data)>::type,
  typename boost::result_of<when<_,A₁>(Expr, State, Data)>::type,
  typename boost::result_of<when<_,A₂>(Expr, State, Data)>::type
)>::type

If T is of the form PolymorphicFunctionObject(A₀,…A_n), then result_type is:

typename boost::result_of<PolymorphicFunctionObject(
  typename boost::result_of<when<_,A₀>(Expr, State, Data)>::type,
  …
  typename boost::result_of<when<_,A_n>(Expr, State, Data)>::type
>::type

If T is of the form PolymorphicFunctionObject(A₀,…A_n ...), then let T' be PolymorphicFunctionObject(A₀,…A_n-1, S), where S is a type sequence computed from the unpacking expression A_n 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

```
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(A₀), then return
```
PrimitiveTransform()(
  when<_,A₀>()(expr, state, data),
  state, 
  sata
)
```
- If T is of the form PrimitiveTransform(A₀, A₁), then return:
```
PrimitiveTransform()(
  when<_,A₀>()(expr, state, data),
  when<_,A₁>()(expr, state, data),
  Data
)
```
- If T is of the form PrimitiveTransform(A₀, A₁, A₂), then return
```
PrimitiveTransform()(
  when<_,A₀>()(expr, state, data),
  when<_,A₁>()(expr, state, data),
  when<_,A₂>()(expr, state, data)
)
```
- If T is of the form PolymorphicFunctionObject(A₀,…A_n), then return:
```
PolymorphicFunctionObject()(
  when<_,A₀>()(expr, state, data),
  ...
  when<_,A_n>()(expr, state, data)
)
```
- If T is of the form PolymorphicFunctionObject(A₀,…A_n ...), then let T' be PolymorphicFunctionObject(A₀,…A_n-1, S), where S is a type sequence computed from the unpacking expression A_n as described in the reference for proto::pack. Then, return:
```
proto::call<T'>()(expr, state, data)
```