[ceph.git] / ceph / src / boost / boost / phoenix / core / detail / cpp03 / preprocessed / phx2_result_10.hpp

/*=============================================================================
    Copyright (c) 2011 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)
==============================================================================*/
    
    
    
    
    
    
    
        template <typename F, typename A0>
        struct has_phx2_result<F, A0>
            : mpl::eval_if<
                has_result_type<F>
              , mpl::false_
              , has_phx2_result_impl<typename F::template result<F(A0)> >
            >::type
        {};
        template <typename F, typename A0>
        struct phx2_result<F, A0>
        {
            typedef typename F::template result<A0>::type type;
        };
        template <typename F, typename A0>
        struct phx2_result<F, A0 &>
        {
            typedef typename F::template result<A0>::type type;
        };
        template <typename F, typename A0>
        struct phx2_result<F, A0 const&>
        {
            typedef typename F::template result<A0>::type type;
        };
    
    
    
    
    
    
    
        template <typename F, typename A0 , typename A1>
        struct has_phx2_result<F, A0 , A1>
            : mpl::eval_if<
                has_result_type<F>
              , mpl::false_
              , has_phx2_result_impl<typename F::template result<F(A0 , A1)> >
            >::type
        {};
        template <typename F, typename A0 , typename A1>
        struct phx2_result<F, A0 , A1>
        {
            typedef typename F::template result<A0 , A1>::type type;
        };
        template <typename F, typename A0 , typename A1>
        struct phx2_result<F, A0 & , A1 &>
        {
            typedef typename F::template result<A0 , A1>::type type;
        };
        template <typename F, typename A0 , typename A1>
        struct phx2_result<F, A0 const& , A1 const&>
        {
            typedef typename F::template result<A0 , A1>::type type;
        };
    
    
    
    
    
    
    
        template <typename F, typename A0 , typename A1 , typename A2>
        struct has_phx2_result<F, A0 , A1 , A2>
            : mpl::eval_if<
                has_result_type<F>
              , mpl::false_
              , has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2)> >
            >::type
        {};
        template <typename F, typename A0 , typename A1 , typename A2>
        struct phx2_result<F, A0 , A1 , A2>
        {
            typedef typename F::template result<A0 , A1 , A2>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2>
        struct phx2_result<F, A0 & , A1 & , A2 &>
        {
            typedef typename F::template result<A0 , A1 , A2>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2>
        struct phx2_result<F, A0 const& , A1 const& , A2 const&>
        {
            typedef typename F::template result<A0 , A1 , A2>::type type;
        };
    
    
    
    
    
    
    
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3>
        struct has_phx2_result<F, A0 , A1 , A2 , A3>
            : mpl::eval_if<
                has_result_type<F>
              , mpl::false_
              , has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3)> >
            >::type
        {};
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3>
        struct phx2_result<F, A0 , A1 , A2 , A3>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3>
        struct phx2_result<F, A0 & , A1 & , A2 & , A3 &>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3>
        struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const&>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3>::type type;
        };
    
    
    
    
    
    
    
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
        struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4>
            : mpl::eval_if<
                has_result_type<F>
              , mpl::false_
              , has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4)> >
            >::type
        {};
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
        struct phx2_result<F, A0 , A1 , A2 , A3 , A4>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
        struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 &>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
        struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const&>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4>::type type;
        };
    
    
    
    
    
    
    
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
        struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5>
            : mpl::eval_if<
                has_result_type<F>
              , mpl::false_
              , has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5)> >
            >::type
        {};
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
        struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
        struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 &>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
        struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const&>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5>::type type;
        };
    
    
    
    
    
    
    
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
        struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6>
            : mpl::eval_if<
                has_result_type<F>
              , mpl::false_
              , has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
            >::type
        {};
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
        struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
        struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 &>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
        struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const&>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type type;
        };
    
    
    
    
    
    
    
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
        struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>
            : mpl::eval_if<
                has_result_type<F>
              , mpl::false_
              , has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
            >::type
        {};
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
        struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
        struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 &>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
        struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const&>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type type;
        };
    
    
    
    
    
    
    
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
        struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>
            : mpl::eval_if<
                has_result_type<F>
              , mpl::false_
              , has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
            >::type
        {};
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
        struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
        struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 &>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
        struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const&>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type type;
        };
Commit	Line	Data
7c673cae FG	1	/*=============================================================================
	2	Copyright (c) 2011 Thomas Heller
	3
	4	Distributed under the Boost Software License, Version 1.0. (See accompanying
	5	file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
	6	==============================================================================*/
	7
	8
	9
	10
	11
	12
	13
	14	template <typename F, typename A0>
	15	struct has_phx2_result<F, A0>
	16	: mpl::eval_if<
	17	has_result_type<F>
	18	, mpl::false_
	19	, has_phx2_result_impl<typename F::template result<F(A0)> >
	20	>::type
	21	{};
	22	template <typename F, typename A0>
	23	struct phx2_result<F, A0>
	24	{
	25	typedef typename F::template result<A0>::type type;
	26	};
	27	template <typename F, typename A0>
	28	struct phx2_result<F, A0 &>
	29	{
	30	typedef typename F::template result<A0>::type type;
	31	};
	32	template <typename F, typename A0>
	33	struct phx2_result<F, A0 const&>
	34	{
	35	typedef typename F::template result<A0>::type type;
	36	};
	37
	38
	39
	40
	41
	42
	43
	44	template <typename F, typename A0 , typename A1>
	45	struct has_phx2_result<F, A0 , A1>
	46	: mpl::eval_if<
	47	has_result_type<F>
	48	, mpl::false_
	49	, has_phx2_result_impl<typename F::template result<F(A0 , A1)> >
	50	>::type
	51	{};
	52	template <typename F, typename A0 , typename A1>
	53	struct phx2_result<F, A0 , A1>
	54	{
	55	typedef typename F::template result<A0 , A1>::type type;
	56	};
	57	template <typename F, typename A0 , typename A1>
	58	struct phx2_result<F, A0 & , A1 &>
	59	{
	60	typedef typename F::template result<A0 , A1>::type type;
	61	};
	62	template <typename F, typename A0 , typename A1>
	63	struct phx2_result<F, A0 const& , A1 const&>
	64	{
65	typedef typename F::template result<A0 , A1>::type type;
66	};
67
68
69
70
71
72
73
74	template <typename F, typename A0 , typename A1 , typename A2>
75	struct has_phx2_result<F, A0 , A1 , A2>
76	: mpl::eval_if<
77	has_result_type<F>
78	, mpl::false_
79	, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2)> >
80	>::type
81	{};
82	template <typename F, typename A0 , typename A1 , typename A2>
83	struct phx2_result<F, A0 , A1 , A2>
84	{
85	typedef typename F::template result<A0 , A1 , A2>::type type;
86	};
87	template <typename F, typename A0 , typename A1 , typename A2>
88	struct phx2_result<F, A0 & , A1 & , A2 &>
89	{
90	typedef typename F::template result<A0 , A1 , A2>::type type;
91	};
92	template <typename F, typename A0 , typename A1 , typename A2>
93	struct phx2_result<F, A0 const& , A1 const& , A2 const&>
94	{
95	typedef typename F::template result<A0 , A1 , A2>::type type;
96	};
97
98
99
100
101
102
103
104	template <typename F, typename A0 , typename A1 , typename A2 , typename A3>
105	struct has_phx2_result<F, A0 , A1 , A2 , A3>
106	: mpl::eval_if<
107	has_result_type<F>
108	, mpl::false_
109	, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3)> >
110	>::type
111	{};
112	template <typename F, typename A0 , typename A1 , typename A2 , typename A3>
113	struct phx2_result<F, A0 , A1 , A2 , A3>
114	{
115	typedef typename F::template result<A0 , A1 , A2 , A3>::type type;
116	};
117	template <typename F, typename A0 , typename A1 , typename A2 , typename A3>
118	struct phx2_result<F, A0 & , A1 & , A2 & , A3 &>
119	{
120	typedef typename F::template result<A0 , A1 , A2 , A3>::type type;
121	};
122	template <typename F, typename A0 , typename A1 , typename A2 , typename A3>
123	struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const&>
124	{
125	typedef typename F::template result<A0 , A1 , A2 , A3>::type type;
126	};
127
128
129
130
131
132
133
134	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
135	struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4>
136	: mpl::eval_if<
137	has_result_type<F>
138	, mpl::false_
139	, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4)> >
140	>::type
141	{};
142	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
143	struct phx2_result<F, A0 , A1 , A2 , A3 , A4>
144	{
145	typedef typename F::template result<A0 , A1 , A2 , A3 , A4>::type type;
146	};
147	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
148	struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 &>
149	{
150	typedef typename F::template result<A0 , A1 , A2 , A3 , A4>::type type;
151	};
152	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
153	struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const&>
154	{
155	typedef typename F::template result<A0 , A1 , A2 , A3 , A4>::type type;
156	};
157
158
159
160
161
162
163
164	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
165	struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5>
166	: mpl::eval_if<
167	has_result_type<F>
168	, mpl::false_
169	, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5)> >
170	>::type
171	{};
172	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
173	struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5>
174	{
175	typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5>::type type;
176	};
177	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
178	struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 &>
179	{
180	typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5>::type type;
181	};
182	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
183	struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const&>
184	{
185	typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5>::type type;
186	};
187
188
189
190
191
192
193
194	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
195	struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6>
196	: mpl::eval_if<
197	has_result_type<F>
198	, mpl::false_
199	, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
200	>::type
201	{};
202	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
203	struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6>
204	{
205	typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type type;
206	};
207	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
208	struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 &>
209	{
210	typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type type;
211	};
212	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
213	struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const&>
214	{
215	typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type type;
216	};
217
218
219
220
221
222
223
224	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
225	struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>
226	: mpl::eval_if<
227	has_result_type<F>
228	, mpl::false_
229	, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
230	>::type
231	{};
232	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
233	struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>
234	{
235	typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type type;
236	};
237	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
238	struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 &>
239	{
240	typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type type;
241	};
242	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
243	struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const&>
244	{
245	typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type type;
246	};
247
248
249
250
251
252
253
254	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
255	struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>
256	: mpl::eval_if<
257	has_result_type<F>
258	, mpl::false_
259	, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
260	>::type
261	{};
262	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
263	struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>
264	{
265	typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type type;
266	};
267	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
268	struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 &>
269	{
270	typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type type;
271	};
272	template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
273	struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const&>
274	{
275	typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type type;
276	};