Struct template impl

boost::proto::_default::impl —

Synopsis

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


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

  // public member functions
  result_type operator()(typename impl::expr_param, 
                         typename impl::state_param, 
                         typename impl::data_param) const;
  static Expr s_expr;  // For exposition only
  static State s_state;  // For exposition only
  static Data s_data;  // For exposition only
};

Description

Let OP be the C++ operator corresponding to Expr::proto_tag. (For example, if Tag is proto::tag::plus, let OP be +.)

The behavior of this class is specified in terms of the C++0x decltype keyword. In systems where this keyword is not available, Proto uses the Boost.Typeof library to approximate the behavior.

`impl` public types

typedef see-below result_type;

If Tag corresponds to a unary prefix operator, then the result type is
```
decltype(
  OP Grammar()(proto::child(s_expr), s_state, s_data)
)
```
If Tag corresponds to a unary postfix operator, then the result type is
```
decltype(
  Grammar()(proto::child(s_expr), s_state, s_data) OP
)
```

If Tag corresponds to a binary infix operator, then the result type is

decltype(
  Grammar()(proto::left(s_expr), s_state, s_data) OP
  Grammar()(proto::right(s_expr), s_state, s_data)
)

If Tag is proto::tag::subscript, then the result type is

decltype(
  Grammar()(proto::left(s_expr), s_state, s_data) [
  Grammar()(proto::right(s_expr), s_state, s_data) ]
)

If Tag is proto::tag::if_else_, then the result type is

decltype(
  Grammar()(proto::child_c<0>(s_expr), s_state, s_data) ?
  Grammar()(proto::child_c<1>(s_expr), s_state, s_data) :
  Grammar()(proto::child_c<2>(s_expr), s_state, s_data)
)

If Tag is proto::tag::function, then the result type is

decltype(
  Grammar()(proto::child_c<0>(s_expr), s_state, s_data) (
  Grammar()(proto::child_c<1>(s_expr), s_state, s_data),
  ...
  Grammar()(proto::child_c<N>(s_expr), s_state, s_data) )
)

`impl` public member functions

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

proto::_default<Grammar>::impl<Expr, State, Data>::operator()

If Tag corresponds to a unary prefix operator, then return
```
OP Grammar()(proto::child(expr), state, data)
```
If Tag corresponds to a unary postfix operator, then return
```
Grammar()(proto::child(expr), state, data) OP
```

If Tag corresponds to a binary infix operator, then return

Grammar()(proto::left(expr), state, data) OP
Grammar()(proto::right(expr), state, data)

If Tag is proto::tag::subscript, then return

Grammar()(proto::left(expr), state, data) [
Grammar()(proto::right(expr), state, data) ]

If Tag is proto::tag::if_else_, then return

Grammar()(proto::child_c<0>(expr), state, data) ?
Grammar()(proto::child_c<1>(expr), state, data) :
Grammar()(proto::child_c<2>(expr), state, data)

If Tag is proto::tag::function, then return

Grammar()(proto::child_c<0>(expr), state, data) (
Grammar()(proto::child_c<1>(expr), state, data),
...
Grammar()(proto::child_c<N>(expr), state, data) )