[ceph.git] / ceph / src / boost / libs / phoenix / include / boost / phoenix / statement / detail / catch_push_back.hpp


#if !BOOST_PHOENIX_IS_ITERATING

#ifndef BOOST_PHOENIX_STATEMENT_DETAIL_CATCH_PUSH_BACK_HPP
#define BOOST_PHOENIX_STATEMENT_DETAIL_CATCH_PUSH_BACK_HPP

#include <boost/phoenix/support/iterate.hpp>

#if !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)

#include <boost/phoenix/statement/detail/preprocessed/catch_push_back.hpp>

#else

#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/catch_push_back_" BOOST_PHOENIX_LIMIT_STR ".hpp")
#endif

/*==============================================================================
    Copyright (c) 2005-2010 Joel de Guzman
    Copyright (c) 2010 Thomas Heller

    Distributed under the Boost Software License, Version 1.0. (See accompanying
    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/

#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 1)
#endif

    #define BOOST_PHOENIX_CATCH_PUSH_BACK_R0(Z, N, DATA)                        \
        BOOST_PP_COMMA_IF(N)                                                    \
        typename proto::result_of::child_c<TryCatch, N>::type                   \
    /**/

    #define BOOST_PHOENIX_CATCH_PUSH_BACK_R1(Z, N, DATA)                        \
        BOOST_PP_COMMA_IF(N) proto::child_c<N>(try_catch)                       \
    /**/

#define BOOST_PHOENIX_ITERATION_PARAMS                                          \
        (3, (2, BOOST_PHOENIX_CATCH_LIMIT,                                      \
        <boost/phoenix/statement/detail/catch_push_back.hpp>))
#include BOOST_PHOENIX_ITERATE()
    
    #undef BOOST_PHOENIX_CATCH_PUSH_BACK_R0
    #undef BOOST_PHOENIX_CATCH_PUSH_BACK_R1

#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif

#endif // BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES

#endif

#else
        template <typename TryCatch, typename Exception, typename Capture, typename Expr>
        struct catch_push_back<TryCatch, Exception, Capture, Expr, BOOST_PHOENIX_ITERATION>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Capture
                  , Expr
                >::type
                catch_expr;

            typedef phoenix::expression::try_catch<
                BOOST_PP_REPEAT(BOOST_PHOENIX_ITERATION, BOOST_PHOENIX_CATCH_PUSH_BACK_R0, _)
              , catch_expr> gen_type;
            typedef typename gen_type::type type;

            static type
            make(
                TryCatch const& try_catch
              , Capture const& capture
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        BOOST_PP_REPEAT(
                            BOOST_PHOENIX_ITERATION
                          , BOOST_PHOENIX_CATCH_PUSH_BACK_R1
                          , _
                        )
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), capture, catch_)
                    );
            }
        };

        template <typename TryCatch, typename Exception, typename Expr>
        struct catch_push_back<TryCatch, Exception, void, Expr, BOOST_PHOENIX_ITERATION>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_
                  , proto::basic_default_domain
                  , catch_exception<Exception>
                  , Expr
                >::type
                catch_expr;

            typedef phoenix::expression::try_catch<
                BOOST_PP_REPEAT(BOOST_PHOENIX_ITERATION, BOOST_PHOENIX_CATCH_PUSH_BACK_R0, _)
              , catch_expr> gen_type;
            typedef typename gen_type::type type;

            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        BOOST_PP_REPEAT(
                            BOOST_PHOENIX_ITERATION
                          , BOOST_PHOENIX_CATCH_PUSH_BACK_R1
                          , _
                        )
                      , proto::make_expr<
                            phoenix::tag::catch_
                          , proto::basic_default_domain
                        >(catch_exception<Exception>(), catch_)
                    );
            }
        };

        template <typename TryCatch, typename Expr>
        struct catch_all_push_back<TryCatch, Expr, BOOST_PHOENIX_ITERATION>
        {
            typedef
                typename proto::result_of::make_expr<
                    phoenix::tag::catch_all
                  , proto::basic_default_domain
                  , Expr
                >::type
                catch_expr;

            typedef phoenix::expression::try_catch<
                BOOST_PP_REPEAT(BOOST_PHOENIX_ITERATION, BOOST_PHOENIX_CATCH_PUSH_BACK_R0, _)
              , catch_expr> gen_type;
            typedef typename gen_type::type type;

            static type
            make(
                TryCatch const& try_catch
              , Expr const& catch_
            )
            {
                return
                    gen_type::make(
                        BOOST_PP_REPEAT(
                            BOOST_PHOENIX_ITERATION
                          , BOOST_PHOENIX_CATCH_PUSH_BACK_R1
                          , _
                        )
                      , proto::make_expr<
                            phoenix::tag::catch_all
                          , proto::basic_default_domain
                        >(catch_)
                    );
            }
        };

#endif
Commit	Line	Data
7c673cae FG	1
	2	#if !BOOST_PHOENIX_IS_ITERATING
	3
	4	#ifndef BOOST_PHOENIX_STATEMENT_DETAIL_CATCH_PUSH_BACK_HPP
	5	#define BOOST_PHOENIX_STATEMENT_DETAIL_CATCH_PUSH_BACK_HPP
	6
	7	#include <boost/phoenix/support/iterate.hpp>
	8
	9	#if !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)
	10
	11	#include <boost/phoenix/statement/detail/preprocessed/catch_push_back.hpp>
	12
	13	#else
	14
	15	#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
	16	#pragma wave option(preserve: 2, line: 0, output: "preprocessed/catch_push_back_" BOOST_PHOENIX_LIMIT_STR ".hpp")
	17	#endif
	18
	19	/*==============================================================================
	20	Copyright (c) 2005-2010 Joel de Guzman
	21	Copyright (c) 2010 Thomas Heller
	22
	23	Distributed under the Boost Software License, Version 1.0. (See accompanying
	24	file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
	25	==============================================================================*/
	26
	27	#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
	28	#pragma wave option(preserve: 1)
	29	#endif
	30
	31	#define BOOST_PHOENIX_CATCH_PUSH_BACK_R0(Z, N, DATA) \
	32	BOOST_PP_COMMA_IF(N) \
	33	typename proto::result_of::child_c<TryCatch, N>::type \
	34	/**/
	35
	36	#define BOOST_PHOENIX_CATCH_PUSH_BACK_R1(Z, N, DATA) \
	37	BOOST_PP_COMMA_IF(N) proto::child_c<N>(try_catch) \
	38	/**/
	39
	40	#define BOOST_PHOENIX_ITERATION_PARAMS \
	41	(3, (2, BOOST_PHOENIX_CATCH_LIMIT, \
	42	<boost/phoenix/statement/detail/catch_push_back.hpp>))
	43	#include BOOST_PHOENIX_ITERATE()
	44
	45	#undef BOOST_PHOENIX_CATCH_PUSH_BACK_R0
	46	#undef BOOST_PHOENIX_CATCH_PUSH_BACK_R1
	47
	48	#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
	49	#pragma wave option(output: null)
	50	#endif
	51
	52	#endif // BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES
	53
	54	#endif
	55
	56	#else
	57	template <typename TryCatch, typename Exception, typename Capture, typename Expr>
	58	struct catch_push_back<TryCatch, Exception, Capture, Expr, BOOST_PHOENIX_ITERATION>
	59	{
	60	typedef
	61	typename proto::result_of::make_expr<
	62	phoenix::tag::catch_
	63	, proto::basic_default_domain
	64	, catch_exception<Exception>
65	, Capture
66	, Expr
67	>::type
68	catch_expr;
69
70	typedef phoenix::expression::try_catch<
71	BOOST_PP_REPEAT(BOOST_PHOENIX_ITERATION, BOOST_PHOENIX_CATCH_PUSH_BACK_R0, _)
72	, catch_expr> gen_type;
73	typedef typename gen_type::type type;
74
75	static type
76	make(
77	TryCatch const& try_catch
78	, Capture const& capture
79	, Expr const& catch_
80	)
81	{
82	return
83	gen_type::make(
84	BOOST_PP_REPEAT(
85	BOOST_PHOENIX_ITERATION
86	, BOOST_PHOENIX_CATCH_PUSH_BACK_R1
87	, _
88	)
89	, proto::make_expr<
90	phoenix::tag::catch_
91	, proto::basic_default_domain
92	>(catch_exception<Exception>(), capture, catch_)
93	);
94	}
95	};
96
97	template <typename TryCatch, typename Exception, typename Expr>
98	struct catch_push_back<TryCatch, Exception, void, Expr, BOOST_PHOENIX_ITERATION>
99	{
100	typedef
101	typename proto::result_of::make_expr<
102	phoenix::tag::catch_
103	, proto::basic_default_domain
104	, catch_exception<Exception>
105	, Expr
106	>::type
107	catch_expr;
108
109	typedef phoenix::expression::try_catch<
110	BOOST_PP_REPEAT(BOOST_PHOENIX_ITERATION, BOOST_PHOENIX_CATCH_PUSH_BACK_R0, _)
111	, catch_expr> gen_type;
112	typedef typename gen_type::type type;
113
114	static type
115	make(
116	TryCatch const& try_catch
117	, Expr const& catch_
118	)
119	{
120	return
121	gen_type::make(
122	BOOST_PP_REPEAT(
123	BOOST_PHOENIX_ITERATION
124	, BOOST_PHOENIX_CATCH_PUSH_BACK_R1
125	, _
126	)
127	, proto::make_expr<
128	phoenix::tag::catch_
129	, proto::basic_default_domain
130	>(catch_exception<Exception>(), catch_)
131	);
132	}
133	};
134
135	template <typename TryCatch, typename Expr>
136	struct catch_all_push_back<TryCatch, Expr, BOOST_PHOENIX_ITERATION>
137	{
138	typedef
139	typename proto::result_of::make_expr<
140	phoenix::tag::catch_all
141	, proto::basic_default_domain
142	, Expr
143	>::type
144	catch_expr;
145
146	typedef phoenix::expression::try_catch<
147	BOOST_PP_REPEAT(BOOST_PHOENIX_ITERATION, BOOST_PHOENIX_CATCH_PUSH_BACK_R0, _)
148	, catch_expr> gen_type;
149	typedef typename gen_type::type type;
150
151	static type
152	make(
153	TryCatch const& try_catch
154	, Expr const& catch_
155	)
156	{
157	return
158	gen_type::make(
159	BOOST_PP_REPEAT(
160	BOOST_PHOENIX_ITERATION
161	, BOOST_PHOENIX_CATCH_PUSH_BACK_R1
162	, _
163	)
164	, proto::make_expr<
165	phoenix::tag::catch_all
166	, proto::basic_default_domain
167	>(catch_)
168	);
169	}
170	};
171
172	#endif