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;

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

`impl` public member functions

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

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)
)