select.hpp File Reference

#include <boost/preprocessor/repeat.hpp>
#include <boost/preprocessor/enum.hpp>
#include <boost/preprocessor/enum_params.hpp>
#include <boost/preprocessor/enum_params_with_defaults.hpp>
#include <boost/preprocessor/inc.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/facilities/intercept.hpp>
#include <boost/spirit/home/classic/namespace.hpp>
#include <boost/spirit/home/classic/core/parser.hpp>
#include <boost/spirit/home/classic/phoenix/tuples.hpp>
#include <boost/spirit/home/classic/dynamic/impl/select.ipp>

Include dependency graph for select.hpp:

This graph shows which files directly or indirectly include this file:

Classes
struct	boost::spirit::select_default_no_fail
struct	boost::spirit::select_default_fail
struct	boost::spirit::select_parser< TupleT, BehaviourT, T >
struct	boost::spirit::select_parser< TupleT, BehaviourT, T >::result< ScannerT >
struct	boost::spirit::select_parser_gen< BehaviourT, T >

Namespaces
	boost
	Duration formatting facet for input.
	boost::spirit

Macros
#define	BOOST_SPIRIT_SELECT_LIMIT   PHOENIX_LIMIT
#define	BOOST_SPIRIT_SELECT_LIMIT_A   3
#define	BOOST_SPIRIT_SELECT_EMBEDDED(z, N, _)   typename impl::as_embedded_parser<BOOST_PP_CAT(ParserT, N)>::type \
#define	BOOST_SPIRIT_SELECT_EMBEDDED_TYPEDEF(z, N, _)
#define	BOOST_SPIRIT_SELECT_CONVERT(z, N, _)   BOOST_PP_CAT(parser_t, N)::convert(BOOST_PP_CAT(p, N)) \
#define	BOOST_SPIRIT_SELECT_PARSER(z, N, _)

Functions
	BOOST_STATIC_ASSERT (PHOENIX_LIMIT<=PHOENIX_LIMIT)
	BOOST_STATIC_ASSERT (PHOENIX_LIMIT > 0)

Variables
select_parser_gen < select_default_no_fail > const	boost::spirit::select_p
select_parser_gen < select_default_fail > const	boost::spirit::select_fail_p

Macro Definition Documentation

#define BOOST_SPIRIT_SELECT_CONVERT	(		z,
			N,
			_
	)		BOOST_PP_CAT(parser_t, N)::convert(BOOST_PP_CAT(p, N)) \

#define BOOST_SPIRIT_SELECT_EMBEDDED	(		z,
			N,
			_
	)		typename impl::as_embedded_parser<BOOST_PP_CAT(ParserT, N)>::type \

#define BOOST_SPIRIT_SELECT_EMBEDDED_TYPEDEF	(		z,
			N,
			_
	)

Value:

typedef impl::as_embedded_parser<BOOST_PP_CAT(ParserT, N)>          \
            BOOST_PP_CAT(parser_t, N);                                      \

#define BOOST_SPIRIT_SELECT_LIMIT   PHOENIX_LIMIT

#define BOOST_SPIRIT_SELECT_LIMIT_A   3

#define BOOST_SPIRIT_SELECT_PARSER	(		z,
			N,
			_
	)

Value:

template <                                                          \
            BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_INC(N), typename ParserT)    \
        >                                                                   \
        select_parser<                                                      \
            ::phoenix::tuple<                                                 \
                BOOST_PP_ENUM_ ## z(BOOST_PP_INC(N),                        \
                    BOOST_SPIRIT_SELECT_EMBEDDED, _)                        \
            >,                                                              \
            BehaviourT,                                                     \
            T                                                               \
        >                                                                   \
        operator()(                                                         \
            BOOST_PP_ENUM_BINARY_PARAMS_Z(z, BOOST_PP_INC(N),               \
                ParserT, const &p)                                          \
        ) const                                                             \
        {                                                                   \
            BOOST_PP_REPEAT_ ## z(BOOST_PP_INC(N),                          \
                BOOST_SPIRIT_SELECT_EMBEDDED_TYPEDEF, _)                    \
                                                                            \
            typedef ::phoenix::tuple<                                         \
                    BOOST_PP_ENUM_BINARY_PARAMS_Z(z, BOOST_PP_INC(N),       \
                        typename parser_t, ::type BOOST_PP_INTERCEPT)       \
                > tuple_t;                                                  \
            typedef select_parser<tuple_t, BehaviourT, T> result_t;         \
                                                                            \
            return result_t(tuple_t(                                        \
                    BOOST_PP_ENUM_ ## z(BOOST_PP_INC(N),                    \
                        BOOST_SPIRIT_SELECT_CONVERT, _)                     \
                ));                                                         \
        }                                                                   \

Function Documentation

BOOST_STATIC_ASSERT

(

PHOENIX_LIMIT<=

PHOENIX_LIMIT

)

BOOST_STATIC_ASSERT	(	PHOENIX_LIMIT	,
		0
	)