rheolef  6.3
field_expr_ops.h
Go to the documentation of this file.
1 #ifndef _RHEOLEF_FIELD_EXPR_OPS_H
2 #define _RHEOLEF_FIELD_EXPR_OPS_H
3 // do not edit !
4 // ./field_expr_ops_make > field_expr_ops.h
5 // Rheolef is free software; you can redistribute it and/or modify
6 #include "rheolef/promote.h"
7 #include "rheolef/field_expr.h"
8 namespace rheolef {
9 template<class T, class M>
10 #if BOOST_VERSION < 104601
11 typename boost::proto::detail::enable_unary<
12  field_domain,
13  is_field<field_basic<T,M> >,
14  field_basic<T,M>,
15  typename boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
16  ::impl<const field_basic<T,M>&>::result_type
17  >::type const
18 operator+ (const field_basic<T,M>& arg)
19 {
20  return boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
21  ::impl<const field_basic<T,M>&>()(arg);
22 }
23 #else // BOOST_VERSION >= 104601
24 typename boost::proto::detail::enable_unary<
25  field_domain,
26  field_domain::proto_grammar,
27  boost::mpl::and_<
28  is_field<field_basic<T,M> >,
29  boost::mpl::not_<boost::proto::is_extension<field_basic<T,M> > >
30  >,
31  boost::proto::tag::unary_plus,
32  field_basic<T,M> const &
33 >::type const
34 operator+ (const field_basic<T,M>& arg)
35 {
36  return boost::proto::detail::make_expr_<boost::proto::tag::unary_plus, field_domain, field_basic<T,M> const &>()(arg);
37 }
38 #endif // BOOST_VERSION
39 template<class T, class M>
40 #if BOOST_VERSION < 104601
41 typename boost::proto::detail::enable_unary<
42  field_domain,
43  is_field<field_indirect<T,M> >,
44  field_indirect<T,M>,
45  typename boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
46  ::impl<const field_indirect<T,M>&>::result_type
47  >::type const
48 operator+ (const field_indirect<T,M>& arg)
49 {
50  return boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
51  ::impl<const field_indirect<T,M>&>()(arg);
52 }
53 #else // BOOST_VERSION >= 104601
54 typename boost::proto::detail::enable_unary<
55  field_domain,
56  field_domain::proto_grammar,
57  boost::mpl::and_<
58  is_field<field_indirect<T,M> >,
59  boost::mpl::not_<boost::proto::is_extension<field_indirect<T,M> > >
60  >,
61  boost::proto::tag::unary_plus,
62  field_indirect<T,M> const &
63 >::type const
64 operator+ (const field_indirect<T,M>& arg)
65 {
66  return boost::proto::detail::make_expr_<boost::proto::tag::unary_plus, field_domain, field_indirect<T,M> const &>()(arg);
67 }
68 #endif // BOOST_VERSION
69 template<class T, class M>
70 #if BOOST_VERSION < 104601
71 typename boost::proto::detail::enable_unary<
72  field_domain,
73  is_field<field_indirect_const<T,M> >,
74  field_indirect_const<T,M>,
75  typename boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
76  ::impl<const field_indirect_const<T,M>&>::result_type
77  >::type const
78 operator+ (const field_indirect_const<T,M>& arg)
79 {
80  return boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
81  ::impl<const field_indirect_const<T,M>&>()(arg);
82 }
83 #else // BOOST_VERSION >= 104601
84 typename boost::proto::detail::enable_unary<
85  field_domain,
86  field_domain::proto_grammar,
87  boost::mpl::and_<
88  is_field<field_indirect_const<T,M> >,
89  boost::mpl::not_<boost::proto::is_extension<field_indirect_const<T,M> > >
90  >,
91  boost::proto::tag::unary_plus,
92  field_indirect_const<T,M> const &
93 >::type const
94 operator+ (const field_indirect_const<T,M>& arg)
95 {
96  return boost::proto::detail::make_expr_<boost::proto::tag::unary_plus, field_domain, field_indirect_const<T,M> const &>()(arg);
97 }
98 #endif // BOOST_VERSION
99 template<class T, class M>
100 #if BOOST_VERSION < 104601
101 typename boost::proto::detail::enable_unary<
102  field_domain,
103  is_field<field_component<T,M> >,
104  field_component<T,M>,
105  typename boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
106  ::impl<const field_component<T,M>&>::result_type
107  >::type const
108 operator+ (const field_component<T,M>& arg)
109 {
110  return boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
111  ::impl<const field_component<T,M>&>()(arg);
112 }
113 #else // BOOST_VERSION >= 104601
114 typename boost::proto::detail::enable_unary<
115  field_domain,
116  field_domain::proto_grammar,
117  boost::mpl::and_<
118  is_field<field_component<T,M> >,
119  boost::mpl::not_<boost::proto::is_extension<field_component<T,M> > >
120  >,
121  boost::proto::tag::unary_plus,
122  field_component<T,M> const &
123 >::type const
124 operator+ (const field_component<T,M>& arg)
125 {
126  return boost::proto::detail::make_expr_<boost::proto::tag::unary_plus, field_domain, field_component<T,M> const &>()(arg);
127 }
128 #endif // BOOST_VERSION
129 template<class T, class M>
130 #if BOOST_VERSION < 104601
131 typename boost::proto::detail::enable_unary<
132  field_domain,
133  is_field<field_component_const<T,M> >,
134  field_component_const<T,M>,
135  typename boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
136  ::impl<const field_component_const<T,M>&>::result_type
137  >::type const
138 operator+ (const field_component_const<T,M>& arg)
139 {
140  return boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
141  ::impl<const field_component_const<T,M>&>()(arg);
142 }
143 #else // BOOST_VERSION >= 104601
144 typename boost::proto::detail::enable_unary<
145  field_domain,
146  field_domain::proto_grammar,
147  boost::mpl::and_<
148  is_field<field_component_const<T,M> >,
149  boost::mpl::not_<boost::proto::is_extension<field_component_const<T,M> > >
150  >,
151  boost::proto::tag::unary_plus,
152  field_component_const<T,M> const &
153 >::type const
154 operator+ (const field_component_const<T,M>& arg)
155 {
156  return boost::proto::detail::make_expr_<boost::proto::tag::unary_plus, field_domain, field_component_const<T,M> const &>()(arg);
157 }
158 #endif // BOOST_VERSION
159 template<class Expr>
160 #if BOOST_VERSION < 104601
161 typename boost::proto::detail::enable_unary<
162  field_domain,
163  is_field<field_expr<Expr> >,
164  field_expr<Expr>,
165  typename boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
166  ::impl<const field_expr<Expr>&>::result_type
167  >::type const
168 operator+ (const field_expr<Expr>& arg)
169 {
170  return boost::proto::functional::make_expr<boost::proto::tag::unary_plus, field_domain>
171  ::impl<const field_expr<Expr>&>()(arg);
172 }
173 #else // BOOST_VERSION >= 104601
174 typename boost::proto::detail::enable_unary<
175  field_domain,
176  field_domain::proto_grammar,
177  boost::mpl::and_<
178  is_field<field_expr<Expr> >,
179  boost::mpl::not_<boost::proto::is_extension<field_expr<Expr> > >
180  >,
181  boost::proto::tag::unary_plus,
182  field_expr<Expr> const &
183 >::type const
184 operator+ (const field_expr<Expr>& arg)
185 {
186  return boost::proto::detail::make_expr_<boost::proto::tag::unary_plus, field_domain, field_expr<Expr> const &>()(arg);
187 }
188 #endif // BOOST_VERSION
189 template<class T, class M>
190 #if BOOST_VERSION < 104601
191 typename boost::proto::detail::enable_unary<
192  field_domain,
193  is_field<field_basic<T,M> >,
194  field_basic<T,M>,
195  typename boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
196  ::impl<const field_basic<T,M>&>::result_type
197  >::type const
198 operator- (const field_basic<T,M>& arg)
199 {
200  return boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
201  ::impl<const field_basic<T,M>&>()(arg);
202 }
203 #else // BOOST_VERSION >= 104601
204 typename boost::proto::detail::enable_unary<
205  field_domain,
206  field_domain::proto_grammar,
207  boost::mpl::and_<
208  is_field<field_basic<T,M> >,
209  boost::mpl::not_<boost::proto::is_extension<field_basic<T,M> > >
210  >,
211  boost::proto::tag::negate,
212  field_basic<T,M> const &
213 >::type const
214 operator- (const field_basic<T,M>& arg)
215 {
216  return boost::proto::detail::make_expr_<boost::proto::tag::negate, field_domain, field_basic<T,M> const &>()(arg);
217 }
218 #endif // BOOST_VERSION
219 template<class T, class M>
220 #if BOOST_VERSION < 104601
221 typename boost::proto::detail::enable_unary<
222  field_domain,
223  is_field<field_indirect<T,M> >,
224  field_indirect<T,M>,
225  typename boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
226  ::impl<const field_indirect<T,M>&>::result_type
227  >::type const
228 operator- (const field_indirect<T,M>& arg)
229 {
230  return boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
231  ::impl<const field_indirect<T,M>&>()(arg);
232 }
233 #else // BOOST_VERSION >= 104601
234 typename boost::proto::detail::enable_unary<
235  field_domain,
236  field_domain::proto_grammar,
237  boost::mpl::and_<
238  is_field<field_indirect<T,M> >,
239  boost::mpl::not_<boost::proto::is_extension<field_indirect<T,M> > >
240  >,
241  boost::proto::tag::negate,
242  field_indirect<T,M> const &
243 >::type const
244 operator- (const field_indirect<T,M>& arg)
245 {
246  return boost::proto::detail::make_expr_<boost::proto::tag::negate, field_domain, field_indirect<T,M> const &>()(arg);
247 }
248 #endif // BOOST_VERSION
249 template<class T, class M>
250 #if BOOST_VERSION < 104601
251 typename boost::proto::detail::enable_unary<
252  field_domain,
253  is_field<field_indirect_const<T,M> >,
254  field_indirect_const<T,M>,
255  typename boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
256  ::impl<const field_indirect_const<T,M>&>::result_type
257  >::type const
258 operator- (const field_indirect_const<T,M>& arg)
259 {
260  return boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
261  ::impl<const field_indirect_const<T,M>&>()(arg);
262 }
263 #else // BOOST_VERSION >= 104601
264 typename boost::proto::detail::enable_unary<
265  field_domain,
266  field_domain::proto_grammar,
267  boost::mpl::and_<
268  is_field<field_indirect_const<T,M> >,
269  boost::mpl::not_<boost::proto::is_extension<field_indirect_const<T,M> > >
270  >,
271  boost::proto::tag::negate,
272  field_indirect_const<T,M> const &
273 >::type const
274 operator- (const field_indirect_const<T,M>& arg)
275 {
276  return boost::proto::detail::make_expr_<boost::proto::tag::negate, field_domain, field_indirect_const<T,M> const &>()(arg);
277 }
278 #endif // BOOST_VERSION
279 template<class T, class M>
280 #if BOOST_VERSION < 104601
281 typename boost::proto::detail::enable_unary<
282  field_domain,
283  is_field<field_component<T,M> >,
284  field_component<T,M>,
285  typename boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
286  ::impl<const field_component<T,M>&>::result_type
287  >::type const
288 operator- (const field_component<T,M>& arg)
289 {
290  return boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
291  ::impl<const field_component<T,M>&>()(arg);
292 }
293 #else // BOOST_VERSION >= 104601
294 typename boost::proto::detail::enable_unary<
295  field_domain,
296  field_domain::proto_grammar,
297  boost::mpl::and_<
298  is_field<field_component<T,M> >,
299  boost::mpl::not_<boost::proto::is_extension<field_component<T,M> > >
300  >,
301  boost::proto::tag::negate,
302  field_component<T,M> const &
303 >::type const
304 operator- (const field_component<T,M>& arg)
305 {
306  return boost::proto::detail::make_expr_<boost::proto::tag::negate, field_domain, field_component<T,M> const &>()(arg);
307 }
308 #endif // BOOST_VERSION
309 template<class T, class M>
310 #if BOOST_VERSION < 104601
311 typename boost::proto::detail::enable_unary<
312  field_domain,
313  is_field<field_component_const<T,M> >,
314  field_component_const<T,M>,
315  typename boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
316  ::impl<const field_component_const<T,M>&>::result_type
317  >::type const
318 operator- (const field_component_const<T,M>& arg)
319 {
320  return boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
321  ::impl<const field_component_const<T,M>&>()(arg);
322 }
323 #else // BOOST_VERSION >= 104601
324 typename boost::proto::detail::enable_unary<
325  field_domain,
326  field_domain::proto_grammar,
327  boost::mpl::and_<
328  is_field<field_component_const<T,M> >,
329  boost::mpl::not_<boost::proto::is_extension<field_component_const<T,M> > >
330  >,
331  boost::proto::tag::negate,
332  field_component_const<T,M> const &
333 >::type const
334 operator- (const field_component_const<T,M>& arg)
335 {
336  return boost::proto::detail::make_expr_<boost::proto::tag::negate, field_domain, field_component_const<T,M> const &>()(arg);
337 }
338 #endif // BOOST_VERSION
339 template<class Expr>
340 #if BOOST_VERSION < 104601
341 typename boost::proto::detail::enable_unary<
342  field_domain,
343  is_field<field_expr<Expr> >,
344  field_expr<Expr>,
345  typename boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
346  ::impl<const field_expr<Expr>&>::result_type
347  >::type const
348 operator- (const field_expr<Expr>& arg)
349 {
350  return boost::proto::functional::make_expr<boost::proto::tag::negate, field_domain>
351  ::impl<const field_expr<Expr>&>()(arg);
352 }
353 #else // BOOST_VERSION >= 104601
354 typename boost::proto::detail::enable_unary<
355  field_domain,
356  field_domain::proto_grammar,
357  boost::mpl::and_<
358  is_field<field_expr<Expr> >,
359  boost::mpl::not_<boost::proto::is_extension<field_expr<Expr> > >
360  >,
361  boost::proto::tag::negate,
362  field_expr<Expr> const &
363 >::type const
364 operator- (const field_expr<Expr>& arg)
365 {
366  return boost::proto::detail::make_expr_<boost::proto::tag::negate, field_domain, field_expr<Expr> const &>()(arg);
367 }
368 #endif // BOOST_VERSION
369 template<class T, class M>
370 #if BOOST_VERSION < 104601
371 typename
372 boost::proto::detail::enable_binary<
373  field_domain,
374  is_field<int >,
375  int,
376  is_field<field_basic<T,M> >,
377  field_basic<T,M>,
378  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
379  ::impl<const int&, const field_basic<T,M>&>::result_type const
380 >::type
381 operator+ (const int& l, const field_basic<T,M>& r)
382 {
383  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
384  ::impl<const int&, const field_basic<T,M>&>() (l, r);
385 }
386 #else // BOOST_VERSION >= 104601
387 typename boost::proto::detail::enable_binary<
388  field_domain,
389  field_domain::proto_grammar,
390  boost::mpl::and_<
391  boost::mpl::or_<is_field<int >, is_field<field_basic<T,M> > >,
392  boost::mpl::not_<
393  boost::mpl::or_<
394  boost::proto::is_extension<int >,
395  boost::proto::is_extension<field_basic<T,M> >
396  >
397  >
398  >,
399  boost::proto::tag::plus,
400  int const &,
401  field_basic<T,M> const &
402 >::type /* const */
403 operator+ (int const &left, field_basic<T,M> const &right)
404 {
405  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, int const &, field_basic<T,M> const &>()(left, right);
406 }
407 #endif // BOOST_VERSION
408 template<class T, class M>
409 #if BOOST_VERSION < 104601
410 typename
411 boost::proto::detail::enable_binary<
412  field_domain,
413  is_field<T >,
414  T,
415  is_field<field_basic<T,M> >,
416  field_basic<T,M>,
417  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
418  ::impl<const T&, const field_basic<T,M>&>::result_type const
419 >::type
420 operator+ (const T& l, const field_basic<T,M>& r)
421 {
422  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
423  ::impl<const T&, const field_basic<T,M>&>() (l, r);
424 }
425 #else // BOOST_VERSION >= 104601
426 typename boost::proto::detail::enable_binary<
427  field_domain,
428  field_domain::proto_grammar,
429  boost::mpl::and_<
430  boost::mpl::or_<is_field<T >, is_field<field_basic<T,M> > >,
431  boost::mpl::not_<
432  boost::mpl::or_<
433  boost::proto::is_extension<T >,
434  boost::proto::is_extension<field_basic<T,M> >
435  >
436  >
437  >,
438  boost::proto::tag::plus,
439  T const &,
440  field_basic<T,M> const &
441 >::type /* const */
442 operator+ (T const &left, field_basic<T,M> const &right)
443 {
444  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, T const &, field_basic<T,M> const &>()(left, right);
445 }
446 #endif // BOOST_VERSION
447 template<class T, class M>
448 #if BOOST_VERSION < 104601
449 typename
450 boost::proto::detail::enable_binary<
451  field_domain,
452  is_field<int >,
453  int,
454  is_field<field_indirect<T,M> >,
455  field_indirect<T,M>,
456  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
457  ::impl<const int&, const field_indirect<T,M>&>::result_type const
458 >::type
459 operator+ (const int& l, const field_indirect<T,M>& r)
460 {
461  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
462  ::impl<const int&, const field_indirect<T,M>&>() (l, r);
463 }
464 #else // BOOST_VERSION >= 104601
465 typename boost::proto::detail::enable_binary<
466  field_domain,
467  field_domain::proto_grammar,
468  boost::mpl::and_<
469  boost::mpl::or_<is_field<int >, is_field<field_indirect<T,M> > >,
470  boost::mpl::not_<
471  boost::mpl::or_<
472  boost::proto::is_extension<int >,
473  boost::proto::is_extension<field_indirect<T,M> >
474  >
475  >
476  >,
477  boost::proto::tag::plus,
478  int const &,
479  field_indirect<T,M> const &
480 >::type /* const */
481 operator+ (int const &left, field_indirect<T,M> const &right)
482 {
483  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, int const &, field_indirect<T,M> const &>()(left, right);
484 }
485 #endif // BOOST_VERSION
486 template<class T, class M>
487 #if BOOST_VERSION < 104601
488 typename
489 boost::proto::detail::enable_binary<
490  field_domain,
491  is_field<T >,
492  T,
493  is_field<field_indirect<T,M> >,
494  field_indirect<T,M>,
495  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
496  ::impl<const T&, const field_indirect<T,M>&>::result_type const
497 >::type
498 operator+ (const T& l, const field_indirect<T,M>& r)
499 {
500  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
501  ::impl<const T&, const field_indirect<T,M>&>() (l, r);
502 }
503 #else // BOOST_VERSION >= 104601
504 typename boost::proto::detail::enable_binary<
505  field_domain,
506  field_domain::proto_grammar,
507  boost::mpl::and_<
508  boost::mpl::or_<is_field<T >, is_field<field_indirect<T,M> > >,
509  boost::mpl::not_<
510  boost::mpl::or_<
511  boost::proto::is_extension<T >,
512  boost::proto::is_extension<field_indirect<T,M> >
513  >
514  >
515  >,
516  boost::proto::tag::plus,
517  T const &,
518  field_indirect<T,M> const &
519 >::type /* const */
520 operator+ (T const &left, field_indirect<T,M> const &right)
521 {
522  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, T const &, field_indirect<T,M> const &>()(left, right);
523 }
524 #endif // BOOST_VERSION
525 template<class T, class M>
526 #if BOOST_VERSION < 104601
527 typename
528 boost::proto::detail::enable_binary<
529  field_domain,
530  is_field<int >,
531  int,
532  is_field<field_indirect_const<T,M> >,
533  field_indirect_const<T,M>,
534  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
535  ::impl<const int&, const field_indirect_const<T,M>&>::result_type const
536 >::type
537 operator+ (const int& l, const field_indirect_const<T,M>& r)
538 {
539  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
540  ::impl<const int&, const field_indirect_const<T,M>&>() (l, r);
541 }
542 #else // BOOST_VERSION >= 104601
543 typename boost::proto::detail::enable_binary<
544  field_domain,
545  field_domain::proto_grammar,
546  boost::mpl::and_<
547  boost::mpl::or_<is_field<int >, is_field<field_indirect_const<T,M> > >,
548  boost::mpl::not_<
549  boost::mpl::or_<
550  boost::proto::is_extension<int >,
551  boost::proto::is_extension<field_indirect_const<T,M> >
552  >
553  >
554  >,
555  boost::proto::tag::plus,
556  int const &,
557  field_indirect_const<T,M> const &
558 >::type /* const */
559 operator+ (int const &left, field_indirect_const<T,M> const &right)
560 {
561  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, int const &, field_indirect_const<T,M> const &>()(left, right);
562 }
563 #endif // BOOST_VERSION
564 template<class T, class M>
565 #if BOOST_VERSION < 104601
566 typename
567 boost::proto::detail::enable_binary<
568  field_domain,
569  is_field<T >,
570  T,
571  is_field<field_indirect_const<T,M> >,
572  field_indirect_const<T,M>,
573  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
574  ::impl<const T&, const field_indirect_const<T,M>&>::result_type const
575 >::type
576 operator+ (const T& l, const field_indirect_const<T,M>& r)
577 {
578  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
579  ::impl<const T&, const field_indirect_const<T,M>&>() (l, r);
580 }
581 #else // BOOST_VERSION >= 104601
582 typename boost::proto::detail::enable_binary<
583  field_domain,
584  field_domain::proto_grammar,
585  boost::mpl::and_<
586  boost::mpl::or_<is_field<T >, is_field<field_indirect_const<T,M> > >,
587  boost::mpl::not_<
588  boost::mpl::or_<
589  boost::proto::is_extension<T >,
590  boost::proto::is_extension<field_indirect_const<T,M> >
591  >
592  >
593  >,
594  boost::proto::tag::plus,
595  T const &,
596  field_indirect_const<T,M> const &
597 >::type /* const */
598 operator+ (T const &left, field_indirect_const<T,M> const &right)
599 {
600  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, T const &, field_indirect_const<T,M> const &>()(left, right);
601 }
602 #endif // BOOST_VERSION
603 template<class T, class M>
604 #if BOOST_VERSION < 104601
605 typename
606 boost::proto::detail::enable_binary<
607  field_domain,
608  is_field<int >,
609  int,
610  is_field<field_component<T,M> >,
611  field_component<T,M>,
612  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
613  ::impl<const int&, const field_component<T,M>&>::result_type const
614 >::type
615 operator+ (const int& l, const field_component<T,M>& r)
616 {
617  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
618  ::impl<const int&, const field_component<T,M>&>() (l, r);
619 }
620 #else // BOOST_VERSION >= 104601
621 typename boost::proto::detail::enable_binary<
622  field_domain,
623  field_domain::proto_grammar,
624  boost::mpl::and_<
625  boost::mpl::or_<is_field<int >, is_field<field_component<T,M> > >,
626  boost::mpl::not_<
627  boost::mpl::or_<
628  boost::proto::is_extension<int >,
629  boost::proto::is_extension<field_component<T,M> >
630  >
631  >
632  >,
633  boost::proto::tag::plus,
634  int const &,
635  field_component<T,M> const &
636 >::type /* const */
637 operator+ (int const &left, field_component<T,M> const &right)
638 {
639  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, int const &, field_component<T,M> const &>()(left, right);
640 }
641 #endif // BOOST_VERSION
642 template<class T, class M>
643 #if BOOST_VERSION < 104601
644 typename
645 boost::proto::detail::enable_binary<
646  field_domain,
647  is_field<T >,
648  T,
649  is_field<field_component<T,M> >,
650  field_component<T,M>,
651  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
652  ::impl<const T&, const field_component<T,M>&>::result_type const
653 >::type
654 operator+ (const T& l, const field_component<T,M>& r)
655 {
656  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
657  ::impl<const T&, const field_component<T,M>&>() (l, r);
658 }
659 #else // BOOST_VERSION >= 104601
660 typename boost::proto::detail::enable_binary<
661  field_domain,
662  field_domain::proto_grammar,
663  boost::mpl::and_<
664  boost::mpl::or_<is_field<T >, is_field<field_component<T,M> > >,
665  boost::mpl::not_<
666  boost::mpl::or_<
667  boost::proto::is_extension<T >,
668  boost::proto::is_extension<field_component<T,M> >
669  >
670  >
671  >,
672  boost::proto::tag::plus,
673  T const &,
674  field_component<T,M> const &
675 >::type /* const */
676 operator+ (T const &left, field_component<T,M> const &right)
677 {
678  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, T const &, field_component<T,M> const &>()(left, right);
679 }
680 #endif // BOOST_VERSION
681 template<class T, class M>
682 #if BOOST_VERSION < 104601
683 typename
684 boost::proto::detail::enable_binary<
685  field_domain,
686  is_field<int >,
687  int,
688  is_field<field_component_const<T,M> >,
689  field_component_const<T,M>,
690  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
691  ::impl<const int&, const field_component_const<T,M>&>::result_type const
692 >::type
693 operator+ (const int& l, const field_component_const<T,M>& r)
694 {
695  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
696  ::impl<const int&, const field_component_const<T,M>&>() (l, r);
697 }
698 #else // BOOST_VERSION >= 104601
699 typename boost::proto::detail::enable_binary<
700  field_domain,
701  field_domain::proto_grammar,
702  boost::mpl::and_<
703  boost::mpl::or_<is_field<int >, is_field<field_component_const<T,M> > >,
704  boost::mpl::not_<
705  boost::mpl::or_<
706  boost::proto::is_extension<int >,
707  boost::proto::is_extension<field_component_const<T,M> >
708  >
709  >
710  >,
711  boost::proto::tag::plus,
712  int const &,
713  field_component_const<T,M> const &
714 >::type /* const */
715 operator+ (int const &left, field_component_const<T,M> const &right)
716 {
717  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, int const &, field_component_const<T,M> const &>()(left, right);
718 }
719 #endif // BOOST_VERSION
720 template<class T, class M>
721 #if BOOST_VERSION < 104601
722 typename
723 boost::proto::detail::enable_binary<
724  field_domain,
725  is_field<T >,
726  T,
727  is_field<field_component_const<T,M> >,
728  field_component_const<T,M>,
729  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
730  ::impl<const T&, const field_component_const<T,M>&>::result_type const
731 >::type
732 operator+ (const T& l, const field_component_const<T,M>& r)
733 {
734  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
735  ::impl<const T&, const field_component_const<T,M>&>() (l, r);
736 }
737 #else // BOOST_VERSION >= 104601
738 typename boost::proto::detail::enable_binary<
739  field_domain,
740  field_domain::proto_grammar,
741  boost::mpl::and_<
742  boost::mpl::or_<is_field<T >, is_field<field_component_const<T,M> > >,
743  boost::mpl::not_<
744  boost::mpl::or_<
745  boost::proto::is_extension<T >,
746  boost::proto::is_extension<field_component_const<T,M> >
747  >
748  >
749  >,
750  boost::proto::tag::plus,
751  T const &,
752  field_component_const<T,M> const &
753 >::type /* const */
754 operator+ (T const &left, field_component_const<T,M> const &right)
755 {
756  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, T const &, field_component_const<T,M> const &>()(left, right);
757 }
758 #endif // BOOST_VERSION
759 template<class T, class M>
760 #if BOOST_VERSION < 104601
761 typename
762 boost::proto::detail::enable_binary<
763  field_domain,
764  is_field<field_basic<T,M> >,
765  field_basic<T,M>,
766  is_field<int >,
767  int,
768  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
769  ::impl<const field_basic<T,M>&, const int&>::result_type const
770 >::type
771 operator+ (const field_basic<T,M>& l, const int& r)
772 {
773  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
774  ::impl<const field_basic<T,M>&, const int&>() (l, r);
775 }
776 #else // BOOST_VERSION >= 104601
777 typename boost::proto::detail::enable_binary<
778  field_domain,
779  field_domain::proto_grammar,
780  boost::mpl::and_<
781  boost::mpl::or_<is_field<field_basic<T,M> >, is_field<int > >,
782  boost::mpl::not_<
783  boost::mpl::or_<
784  boost::proto::is_extension<field_basic<T,M> >,
785  boost::proto::is_extension<int >
786  >
787  >
788  >,
789  boost::proto::tag::plus,
790  field_basic<T,M> const &,
791  int const &
792 >::type /* const */
793 operator+ (field_basic<T,M> const &left, int const &right)
794 {
795  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_basic<T,M> const &, int const &>()(left, right);
796 }
797 #endif // BOOST_VERSION
798 template<class T, class M>
799 #if BOOST_VERSION < 104601
800 typename
801 boost::proto::detail::enable_binary<
802  field_domain,
803  is_field<field_basic<T,M> >,
804  field_basic<T,M>,
805  is_field<T >,
806  T,
807  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
808  ::impl<const field_basic<T,M>&, const T&>::result_type const
809 >::type
810 operator+ (const field_basic<T,M>& l, const T& r)
811 {
812  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
813  ::impl<const field_basic<T,M>&, const T&>() (l, r);
814 }
815 #else // BOOST_VERSION >= 104601
816 typename boost::proto::detail::enable_binary<
817  field_domain,
818  field_domain::proto_grammar,
819  boost::mpl::and_<
820  boost::mpl::or_<is_field<field_basic<T,M> >, is_field<T > >,
821  boost::mpl::not_<
822  boost::mpl::or_<
823  boost::proto::is_extension<field_basic<T,M> >,
824  boost::proto::is_extension<T >
825  >
826  >
827  >,
828  boost::proto::tag::plus,
829  field_basic<T,M> const &,
830  T const &
831 >::type /* const */
832 operator+ (field_basic<T,M> const &left, T const &right)
833 {
834  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_basic<T,M> const &, T const &>()(left, right);
835 }
836 #endif // BOOST_VERSION
837 template<class T, class M>
838 #if BOOST_VERSION < 104601
839 typename
840 boost::proto::detail::enable_binary<
841  field_domain,
842  is_field<field_indirect<T,M> >,
843  field_indirect<T,M>,
844  is_field<int >,
845  int,
846  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
847  ::impl<const field_indirect<T,M>&, const int&>::result_type const
848 >::type
849 operator+ (const field_indirect<T,M>& l, const int& r)
850 {
851  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
852  ::impl<const field_indirect<T,M>&, const int&>() (l, r);
853 }
854 #else // BOOST_VERSION >= 104601
855 typename boost::proto::detail::enable_binary<
856  field_domain,
857  field_domain::proto_grammar,
858  boost::mpl::and_<
859  boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<int > >,
860  boost::mpl::not_<
861  boost::mpl::or_<
862  boost::proto::is_extension<field_indirect<T,M> >,
863  boost::proto::is_extension<int >
864  >
865  >
866  >,
867  boost::proto::tag::plus,
868  field_indirect<T,M> const &,
869  int const &
870 >::type /* const */
871 operator+ (field_indirect<T,M> const &left, int const &right)
872 {
873  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect<T,M> const &, int const &>()(left, right);
874 }
875 #endif // BOOST_VERSION
876 template<class T, class M>
877 #if BOOST_VERSION < 104601
878 typename
879 boost::proto::detail::enable_binary<
880  field_domain,
881  is_field<field_indirect<T,M> >,
882  field_indirect<T,M>,
883  is_field<T >,
884  T,
885  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
886  ::impl<const field_indirect<T,M>&, const T&>::result_type const
887 >::type
888 operator+ (const field_indirect<T,M>& l, const T& r)
889 {
890  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
891  ::impl<const field_indirect<T,M>&, const T&>() (l, r);
892 }
893 #else // BOOST_VERSION >= 104601
894 typename boost::proto::detail::enable_binary<
895  field_domain,
896  field_domain::proto_grammar,
897  boost::mpl::and_<
898  boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<T > >,
899  boost::mpl::not_<
900  boost::mpl::or_<
901  boost::proto::is_extension<field_indirect<T,M> >,
902  boost::proto::is_extension<T >
903  >
904  >
905  >,
906  boost::proto::tag::plus,
907  field_indirect<T,M> const &,
908  T const &
909 >::type /* const */
910 operator+ (field_indirect<T,M> const &left, T const &right)
911 {
912  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect<T,M> const &, T const &>()(left, right);
913 }
914 #endif // BOOST_VERSION
915 template<class T, class M>
916 #if BOOST_VERSION < 104601
917 typename
918 boost::proto::detail::enable_binary<
919  field_domain,
920  is_field<field_indirect_const<T,M> >,
921  field_indirect_const<T,M>,
922  is_field<int >,
923  int,
924  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
925  ::impl<const field_indirect_const<T,M>&, const int&>::result_type const
926 >::type
927 operator+ (const field_indirect_const<T,M>& l, const int& r)
928 {
929  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
930  ::impl<const field_indirect_const<T,M>&, const int&>() (l, r);
931 }
932 #else // BOOST_VERSION >= 104601
933 typename boost::proto::detail::enable_binary<
934  field_domain,
935  field_domain::proto_grammar,
936  boost::mpl::and_<
937  boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<int > >,
938  boost::mpl::not_<
939  boost::mpl::or_<
940  boost::proto::is_extension<field_indirect_const<T,M> >,
941  boost::proto::is_extension<int >
942  >
943  >
944  >,
945  boost::proto::tag::plus,
946  field_indirect_const<T,M> const &,
947  int const &
948 >::type /* const */
949 operator+ (field_indirect_const<T,M> const &left, int const &right)
950 {
951  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect_const<T,M> const &, int const &>()(left, right);
952 }
953 #endif // BOOST_VERSION
954 template<class T, class M>
955 #if BOOST_VERSION < 104601
956 typename
957 boost::proto::detail::enable_binary<
958  field_domain,
959  is_field<field_indirect_const<T,M> >,
960  field_indirect_const<T,M>,
961  is_field<T >,
962  T,
963  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
964  ::impl<const field_indirect_const<T,M>&, const T&>::result_type const
965 >::type
966 operator+ (const field_indirect_const<T,M>& l, const T& r)
967 {
968  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
969  ::impl<const field_indirect_const<T,M>&, const T&>() (l, r);
970 }
971 #else // BOOST_VERSION >= 104601
972 typename boost::proto::detail::enable_binary<
973  field_domain,
974  field_domain::proto_grammar,
975  boost::mpl::and_<
976  boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<T > >,
977  boost::mpl::not_<
978  boost::mpl::or_<
979  boost::proto::is_extension<field_indirect_const<T,M> >,
980  boost::proto::is_extension<T >
981  >
982  >
983  >,
984  boost::proto::tag::plus,
985  field_indirect_const<T,M> const &,
986  T const &
987 >::type /* const */
988 operator+ (field_indirect_const<T,M> const &left, T const &right)
989 {
990  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect_const<T,M> const &, T const &>()(left, right);
991 }
992 #endif // BOOST_VERSION
993 template<class T, class M>
994 #if BOOST_VERSION < 104601
995 typename
996 boost::proto::detail::enable_binary<
997  field_domain,
998  is_field<field_component<T,M> >,
999  field_component<T,M>,
1000  is_field<int >,
1001  int,
1002  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1003  ::impl<const field_component<T,M>&, const int&>::result_type const
1004 >::type
1005 operator+ (const field_component<T,M>& l, const int& r)
1006 {
1007  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1008  ::impl<const field_component<T,M>&, const int&>() (l, r);
1009 }
1010 #else // BOOST_VERSION >= 104601
1011 typename boost::proto::detail::enable_binary<
1012  field_domain,
1013  field_domain::proto_grammar,
1014  boost::mpl::and_<
1015  boost::mpl::or_<is_field<field_component<T,M> >, is_field<int > >,
1016  boost::mpl::not_<
1017  boost::mpl::or_<
1018  boost::proto::is_extension<field_component<T,M> >,
1019  boost::proto::is_extension<int >
1020  >
1021  >
1022  >,
1023  boost::proto::tag::plus,
1024  field_component<T,M> const &,
1025  int const &
1026 >::type /* const */
1027 operator+ (field_component<T,M> const &left, int const &right)
1028 {
1029  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component<T,M> const &, int const &>()(left, right);
1030 }
1031 #endif // BOOST_VERSION
1032 template<class T, class M>
1033 #if BOOST_VERSION < 104601
1034 typename
1035 boost::proto::detail::enable_binary<
1036  field_domain,
1037  is_field<field_component<T,M> >,
1038  field_component<T,M>,
1039  is_field<T >,
1040  T,
1041  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1042  ::impl<const field_component<T,M>&, const T&>::result_type const
1043 >::type
1044 operator+ (const field_component<T,M>& l, const T& r)
1045 {
1046  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1047  ::impl<const field_component<T,M>&, const T&>() (l, r);
1048 }
1049 #else // BOOST_VERSION >= 104601
1050 typename boost::proto::detail::enable_binary<
1051  field_domain,
1052  field_domain::proto_grammar,
1053  boost::mpl::and_<
1054  boost::mpl::or_<is_field<field_component<T,M> >, is_field<T > >,
1055  boost::mpl::not_<
1056  boost::mpl::or_<
1057  boost::proto::is_extension<field_component<T,M> >,
1058  boost::proto::is_extension<T >
1059  >
1060  >
1061  >,
1062  boost::proto::tag::plus,
1063  field_component<T,M> const &,
1064  T const &
1065 >::type /* const */
1066 operator+ (field_component<T,M> const &left, T const &right)
1067 {
1068  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component<T,M> const &, T const &>()(left, right);
1069 }
1070 #endif // BOOST_VERSION
1071 template<class T, class M>
1072 #if BOOST_VERSION < 104601
1073 typename
1074 boost::proto::detail::enable_binary<
1075  field_domain,
1076  is_field<field_component_const<T,M> >,
1077  field_component_const<T,M>,
1078  is_field<int >,
1079  int,
1080  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1081  ::impl<const field_component_const<T,M>&, const int&>::result_type const
1082 >::type
1083 operator+ (const field_component_const<T,M>& l, const int& r)
1084 {
1085  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1086  ::impl<const field_component_const<T,M>&, const int&>() (l, r);
1087 }
1088 #else // BOOST_VERSION >= 104601
1089 typename boost::proto::detail::enable_binary<
1090  field_domain,
1091  field_domain::proto_grammar,
1092  boost::mpl::and_<
1093  boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<int > >,
1094  boost::mpl::not_<
1095  boost::mpl::or_<
1096  boost::proto::is_extension<field_component_const<T,M> >,
1097  boost::proto::is_extension<int >
1098  >
1099  >
1100  >,
1101  boost::proto::tag::plus,
1102  field_component_const<T,M> const &,
1103  int const &
1104 >::type /* const */
1105 operator+ (field_component_const<T,M> const &left, int const &right)
1106 {
1107  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component_const<T,M> const &, int const &>()(left, right);
1108 }
1109 #endif // BOOST_VERSION
1110 template<class T, class M>
1111 #if BOOST_VERSION < 104601
1112 typename
1113 boost::proto::detail::enable_binary<
1114  field_domain,
1115  is_field<field_component_const<T,M> >,
1116  field_component_const<T,M>,
1117  is_field<T >,
1118  T,
1119  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1120  ::impl<const field_component_const<T,M>&, const T&>::result_type const
1121 >::type
1122 operator+ (const field_component_const<T,M>& l, const T& r)
1123 {
1124  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1125  ::impl<const field_component_const<T,M>&, const T&>() (l, r);
1126 }
1127 #else // BOOST_VERSION >= 104601
1128 typename boost::proto::detail::enable_binary<
1129  field_domain,
1130  field_domain::proto_grammar,
1131  boost::mpl::and_<
1132  boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<T > >,
1133  boost::mpl::not_<
1134  boost::mpl::or_<
1135  boost::proto::is_extension<field_component_const<T,M> >,
1136  boost::proto::is_extension<T >
1137  >
1138  >
1139  >,
1140  boost::proto::tag::plus,
1141  field_component_const<T,M> const &,
1142  T const &
1143 >::type /* const */
1144 operator+ (field_component_const<T,M> const &left, T const &right)
1145 {
1146  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component_const<T,M> const &, T const &>()(left, right);
1147 }
1148 #endif // BOOST_VERSION
1149 template<class Expr>
1150 #if BOOST_VERSION < 104601
1151 typename
1152 boost::proto::detail::enable_binary<
1153  field_domain,
1154  is_field<int >,
1155  int,
1156  is_field<field_expr<Expr> >,
1157  field_expr<Expr>,
1158  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1159  ::impl<const int&, const field_expr<Expr>&>::result_type const
1160 >::type
1161 operator+ (const int& l, const field_expr<Expr>& r)
1162 {
1163  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1164  ::impl<const int&, const field_expr<Expr>&>() (l, r);
1165 }
1166 #else // BOOST_VERSION >= 104601
1167 typename boost::proto::detail::enable_binary<
1168  field_domain,
1169  field_domain::proto_grammar,
1170  boost::mpl::and_<
1171  boost::mpl::or_<is_field<int >, is_field<field_expr<Expr> > >,
1172  boost::mpl::not_<
1173  boost::mpl::or_<
1174  boost::proto::is_extension<int >,
1175  boost::proto::is_extension<field_expr<Expr> >
1176  >
1177  >
1178  >,
1179  boost::proto::tag::plus,
1180  int const &,
1181  field_expr<Expr> const &
1182 >::type /* const */
1183 operator+ (int const &left, field_expr<Expr> const &right)
1184 {
1185  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, int const &, field_expr<Expr> const &>()(left, right);
1186 }
1187 #endif // BOOST_VERSION
1188 template<class Expr>
1189 #if BOOST_VERSION < 104601
1190 typename
1191 boost::proto::detail::enable_binary<
1192  field_domain,
1193  is_field<field_expr<Expr> >,
1194  field_expr<Expr>,
1195  is_field<int >,
1196  int,
1197  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1198  ::impl<const field_expr<Expr>&, const int&>::result_type const
1199 >::type
1200 operator+ (const field_expr<Expr>& l, const int& r)
1201 {
1202  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1203  ::impl<const field_expr<Expr>&, const int&>() (l, r);
1204 }
1205 #else // BOOST_VERSION >= 104601
1206 typename boost::proto::detail::enable_binary<
1207  field_domain,
1208  field_domain::proto_grammar,
1209  boost::mpl::and_<
1210  boost::mpl::or_<is_field<field_expr<Expr> >, is_field<int > >,
1211  boost::mpl::not_<
1212  boost::mpl::or_<
1213  boost::proto::is_extension<field_expr<Expr> >,
1214  boost::proto::is_extension<int >
1215  >
1216  >
1217  >,
1218  boost::proto::tag::plus,
1219  field_expr<Expr> const &,
1220  int const &
1221 >::type /* const */
1222 operator+ (field_expr<Expr> const &left, int const &right)
1223 {
1224  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_expr<Expr> const &, int const &>()(left, right);
1225 }
1226 #endif // BOOST_VERSION
1227 template<class T, class Expr>
1228 #if BOOST_VERSION < 104601
1229 typename
1230 boost::proto::detail::enable_binary<
1231  field_domain,
1232  is_field<T >,
1233  T,
1234  is_field<field_expr<Expr> >,
1235  field_expr<Expr>,
1236  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1237  ::impl<const T&, const field_expr<Expr>&>::result_type const
1238 >::type
1239 operator+ (const T& l, const field_expr<Expr>& r)
1240 {
1241  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1242  ::impl<const T&, const field_expr<Expr>&>() (l, r);
1243 }
1244 #else // BOOST_VERSION >= 104601
1245 typename boost::proto::detail::enable_binary<
1246  field_domain,
1247  field_domain::proto_grammar,
1248  boost::mpl::and_<
1249  boost::mpl::or_<is_field<T >, is_field<field_expr<Expr> > >,
1250  boost::mpl::not_<
1251  boost::mpl::or_<
1252  boost::proto::is_extension<T >,
1253  boost::proto::is_extension<field_expr<Expr> >
1254  >
1255  >
1256  >,
1257  boost::proto::tag::plus,
1258  T const &,
1259  field_expr<Expr> const &
1260 >::type /* const */
1261 operator+ (T const &left, field_expr<Expr> const &right)
1262 {
1263  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, T const &, field_expr<Expr> const &>()(left, right);
1264 }
1265 #endif // BOOST_VERSION
1266 template<class T, class Expr>
1267 #if BOOST_VERSION < 104601
1268 typename
1269 boost::proto::detail::enable_binary<
1270  field_domain,
1271  is_field<field_expr<Expr> >,
1272  field_expr<Expr>,
1273  is_field<T >,
1274  T,
1275  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1276  ::impl<const field_expr<Expr>&, const T&>::result_type const
1277 >::type
1278 operator+ (const field_expr<Expr>& l, const T& r)
1279 {
1280  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1281  ::impl<const field_expr<Expr>&, const T&>() (l, r);
1282 }
1283 #else // BOOST_VERSION >= 104601
1284 typename boost::proto::detail::enable_binary<
1285  field_domain,
1286  field_domain::proto_grammar,
1287  boost::mpl::and_<
1288  boost::mpl::or_<is_field<field_expr<Expr> >, is_field<T > >,
1289  boost::mpl::not_<
1290  boost::mpl::or_<
1291  boost::proto::is_extension<field_expr<Expr> >,
1292  boost::proto::is_extension<T >
1293  >
1294  >
1295  >,
1296  boost::proto::tag::plus,
1297  field_expr<Expr> const &,
1298  T const &
1299 >::type /* const */
1300 operator+ (field_expr<Expr> const &left, T const &right)
1301 {
1302  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_expr<Expr> const &, T const &>()(left, right);
1303 }
1304 #endif // BOOST_VERSION
1305 template<class T1, class T2, class M>
1306 #if BOOST_VERSION < 104601
1307 typename
1308 boost::proto::detail::enable_binary<
1309  field_domain,
1310  is_field<field_basic<T1,M> >,
1311  field_basic<T1,M>,
1312  is_field<field_basic<T2,M> >,
1313  field_basic<T2,M>,
1314  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1315  ::impl<const field_basic<T1,M>&, const field_basic<T2,M>&>::result_type const
1316 >::type
1317 operator+ (const field_basic<T1,M>& l, const field_basic<T2,M>& r)
1318 {
1319  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1320  ::impl<const field_basic<T1,M>&, const field_basic<T2,M>&>() (l, r);
1321 }
1322 #else // BOOST_VERSION >= 104601
1323 typename boost::proto::detail::enable_binary<
1324  field_domain,
1325  field_domain::proto_grammar,
1326  boost::mpl::and_<
1327  boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_basic<T2,M> > >,
1328  boost::mpl::not_<
1329  boost::mpl::or_<
1330  boost::proto::is_extension<field_basic<T1,M> >,
1331  boost::proto::is_extension<field_basic<T2,M> >
1332  >
1333  >
1334  >,
1335  boost::proto::tag::plus,
1336  field_basic<T1,M> const &,
1337  field_basic<T2,M> const &
1338 >::type /* const */
1339 operator+ (field_basic<T1,M> const &left, field_basic<T2,M> const &right)
1340 {
1341  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_basic<T1,M> const &, field_basic<T2,M> const &>()(left, right);
1342 }
1343 #endif // BOOST_VERSION
1344 template<class T1, class T2, class M>
1345 #if BOOST_VERSION < 104601
1346 typename
1347 boost::proto::detail::enable_binary<
1348  field_domain,
1349  is_field<field_basic<T1,M> >,
1350  field_basic<T1,M>,
1351  is_field<field_indirect<T2,M> >,
1352  field_indirect<T2,M>,
1353  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1354  ::impl<const field_basic<T1,M>&, const field_indirect<T2,M>&>::result_type const
1355 >::type
1356 operator+ (const field_basic<T1,M>& l, const field_indirect<T2,M>& r)
1357 {
1358  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1359  ::impl<const field_basic<T1,M>&, const field_indirect<T2,M>&>() (l, r);
1360 }
1361 #else // BOOST_VERSION >= 104601
1362 typename boost::proto::detail::enable_binary<
1363  field_domain,
1364  field_domain::proto_grammar,
1365  boost::mpl::and_<
1366  boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_indirect<T2,M> > >,
1367  boost::mpl::not_<
1368  boost::mpl::or_<
1369  boost::proto::is_extension<field_basic<T1,M> >,
1370  boost::proto::is_extension<field_indirect<T2,M> >
1371  >
1372  >
1373  >,
1374  boost::proto::tag::plus,
1375  field_basic<T1,M> const &,
1376  field_indirect<T2,M> const &
1377 >::type /* const */
1378 operator+ (field_basic<T1,M> const &left, field_indirect<T2,M> const &right)
1379 {
1380  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_basic<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
1381 }
1382 #endif // BOOST_VERSION
1383 template<class T1, class T2, class M>
1384 #if BOOST_VERSION < 104601
1385 typename
1386 boost::proto::detail::enable_binary<
1387  field_domain,
1388  is_field<field_basic<T1,M> >,
1389  field_basic<T1,M>,
1390  is_field<field_indirect_const<T2,M> >,
1391  field_indirect_const<T2,M>,
1392  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1393  ::impl<const field_basic<T1,M>&, const field_indirect_const<T2,M>&>::result_type const
1394 >::type
1395 operator+ (const field_basic<T1,M>& l, const field_indirect_const<T2,M>& r)
1396 {
1397  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1398  ::impl<const field_basic<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
1399 }
1400 #else // BOOST_VERSION >= 104601
1401 typename boost::proto::detail::enable_binary<
1402  field_domain,
1403  field_domain::proto_grammar,
1404  boost::mpl::and_<
1405  boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_indirect_const<T2,M> > >,
1406  boost::mpl::not_<
1407  boost::mpl::or_<
1408  boost::proto::is_extension<field_basic<T1,M> >,
1409  boost::proto::is_extension<field_indirect_const<T2,M> >
1410  >
1411  >
1412  >,
1413  boost::proto::tag::plus,
1414  field_basic<T1,M> const &,
1415  field_indirect_const<T2,M> const &
1416 >::type /* const */
1417 operator+ (field_basic<T1,M> const &left, field_indirect_const<T2,M> const &right)
1418 {
1419  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_basic<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
1420 }
1421 #endif // BOOST_VERSION
1422 template<class T1, class T2, class M>
1423 #if BOOST_VERSION < 104601
1424 typename
1425 boost::proto::detail::enable_binary<
1426  field_domain,
1427  is_field<field_basic<T1,M> >,
1428  field_basic<T1,M>,
1429  is_field<field_component<T2,M> >,
1430  field_component<T2,M>,
1431  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1432  ::impl<const field_basic<T1,M>&, const field_component<T2,M>&>::result_type const
1433 >::type
1434 operator+ (const field_basic<T1,M>& l, const field_component<T2,M>& r)
1435 {
1436  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1437  ::impl<const field_basic<T1,M>&, const field_component<T2,M>&>() (l, r);
1438 }
1439 #else // BOOST_VERSION >= 104601
1440 typename boost::proto::detail::enable_binary<
1441  field_domain,
1442  field_domain::proto_grammar,
1443  boost::mpl::and_<
1444  boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_component<T2,M> > >,
1445  boost::mpl::not_<
1446  boost::mpl::or_<
1447  boost::proto::is_extension<field_basic<T1,M> >,
1448  boost::proto::is_extension<field_component<T2,M> >
1449  >
1450  >
1451  >,
1452  boost::proto::tag::plus,
1453  field_basic<T1,M> const &,
1454  field_component<T2,M> const &
1455 >::type /* const */
1456 operator+ (field_basic<T1,M> const &left, field_component<T2,M> const &right)
1457 {
1458  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_basic<T1,M> const &, field_component<T2,M> const &>()(left, right);
1459 }
1460 #endif // BOOST_VERSION
1461 template<class T1, class T2, class M>
1462 #if BOOST_VERSION < 104601
1463 typename
1464 boost::proto::detail::enable_binary<
1465  field_domain,
1466  is_field<field_basic<T1,M> >,
1467  field_basic<T1,M>,
1468  is_field<field_component_const<T2,M> >,
1469  field_component_const<T2,M>,
1470  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1471  ::impl<const field_basic<T1,M>&, const field_component_const<T2,M>&>::result_type const
1472 >::type
1473 operator+ (const field_basic<T1,M>& l, const field_component_const<T2,M>& r)
1474 {
1475  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1476  ::impl<const field_basic<T1,M>&, const field_component_const<T2,M>&>() (l, r);
1477 }
1478 #else // BOOST_VERSION >= 104601
1479 typename boost::proto::detail::enable_binary<
1480  field_domain,
1481  field_domain::proto_grammar,
1482  boost::mpl::and_<
1483  boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_component_const<T2,M> > >,
1484  boost::mpl::not_<
1485  boost::mpl::or_<
1486  boost::proto::is_extension<field_basic<T1,M> >,
1487  boost::proto::is_extension<field_component_const<T2,M> >
1488  >
1489  >
1490  >,
1491  boost::proto::tag::plus,
1492  field_basic<T1,M> const &,
1493  field_component_const<T2,M> const &
1494 >::type /* const */
1495 operator+ (field_basic<T1,M> const &left, field_component_const<T2,M> const &right)
1496 {
1497  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_basic<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
1498 }
1499 #endif // BOOST_VERSION
1500 template<class T1, class T2, class M>
1501 #if BOOST_VERSION < 104601
1502 typename
1503 boost::proto::detail::enable_binary<
1504  field_domain,
1505  is_field<field_indirect<T1,M> >,
1506  field_indirect<T1,M>,
1507  is_field<field_basic<T2,M> >,
1508  field_basic<T2,M>,
1509  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1510  ::impl<const field_indirect<T1,M>&, const field_basic<T2,M>&>::result_type const
1511 >::type
1512 operator+ (const field_indirect<T1,M>& l, const field_basic<T2,M>& r)
1513 {
1514  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1515  ::impl<const field_indirect<T1,M>&, const field_basic<T2,M>&>() (l, r);
1516 }
1517 #else // BOOST_VERSION >= 104601
1518 typename boost::proto::detail::enable_binary<
1519  field_domain,
1520  field_domain::proto_grammar,
1521  boost::mpl::and_<
1522  boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_basic<T2,M> > >,
1523  boost::mpl::not_<
1524  boost::mpl::or_<
1525  boost::proto::is_extension<field_indirect<T1,M> >,
1526  boost::proto::is_extension<field_basic<T2,M> >
1527  >
1528  >
1529  >,
1530  boost::proto::tag::plus,
1531  field_indirect<T1,M> const &,
1532  field_basic<T2,M> const &
1533 >::type /* const */
1534 operator+ (field_indirect<T1,M> const &left, field_basic<T2,M> const &right)
1535 {
1536  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect<T1,M> const &, field_basic<T2,M> const &>()(left, right);
1537 }
1538 #endif // BOOST_VERSION
1539 template<class T1, class T2, class M>
1540 #if BOOST_VERSION < 104601
1541 typename
1542 boost::proto::detail::enable_binary<
1543  field_domain,
1544  is_field<field_indirect<T1,M> >,
1545  field_indirect<T1,M>,
1546  is_field<field_indirect<T2,M> >,
1547  field_indirect<T2,M>,
1548  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1549  ::impl<const field_indirect<T1,M>&, const field_indirect<T2,M>&>::result_type const
1550 >::type
1551 operator+ (const field_indirect<T1,M>& l, const field_indirect<T2,M>& r)
1552 {
1553  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1554  ::impl<const field_indirect<T1,M>&, const field_indirect<T2,M>&>() (l, r);
1555 }
1556 #else // BOOST_VERSION >= 104601
1557 typename boost::proto::detail::enable_binary<
1558  field_domain,
1559  field_domain::proto_grammar,
1560  boost::mpl::and_<
1561  boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_indirect<T2,M> > >,
1562  boost::mpl::not_<
1563  boost::mpl::or_<
1564  boost::proto::is_extension<field_indirect<T1,M> >,
1565  boost::proto::is_extension<field_indirect<T2,M> >
1566  >
1567  >
1568  >,
1569  boost::proto::tag::plus,
1570  field_indirect<T1,M> const &,
1571  field_indirect<T2,M> const &
1572 >::type /* const */
1573 operator+ (field_indirect<T1,M> const &left, field_indirect<T2,M> const &right)
1574 {
1575  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
1576 }
1577 #endif // BOOST_VERSION
1578 template<class T1, class T2, class M>
1579 #if BOOST_VERSION < 104601
1580 typename
1581 boost::proto::detail::enable_binary<
1582  field_domain,
1583  is_field<field_indirect<T1,M> >,
1584  field_indirect<T1,M>,
1585  is_field<field_indirect_const<T2,M> >,
1586  field_indirect_const<T2,M>,
1587  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1588  ::impl<const field_indirect<T1,M>&, const field_indirect_const<T2,M>&>::result_type const
1589 >::type
1590 operator+ (const field_indirect<T1,M>& l, const field_indirect_const<T2,M>& r)
1591 {
1592  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1593  ::impl<const field_indirect<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
1594 }
1595 #else // BOOST_VERSION >= 104601
1596 typename boost::proto::detail::enable_binary<
1597  field_domain,
1598  field_domain::proto_grammar,
1599  boost::mpl::and_<
1600  boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_indirect_const<T2,M> > >,
1601  boost::mpl::not_<
1602  boost::mpl::or_<
1603  boost::proto::is_extension<field_indirect<T1,M> >,
1604  boost::proto::is_extension<field_indirect_const<T2,M> >
1605  >
1606  >
1607  >,
1608  boost::proto::tag::plus,
1609  field_indirect<T1,M> const &,
1610  field_indirect_const<T2,M> const &
1611 >::type /* const */
1612 operator+ (field_indirect<T1,M> const &left, field_indirect_const<T2,M> const &right)
1613 {
1614  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
1615 }
1616 #endif // BOOST_VERSION
1617 template<class T1, class T2, class M>
1618 #if BOOST_VERSION < 104601
1619 typename
1620 boost::proto::detail::enable_binary<
1621  field_domain,
1622  is_field<field_indirect<T1,M> >,
1623  field_indirect<T1,M>,
1624  is_field<field_component<T2,M> >,
1625  field_component<T2,M>,
1626  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1627  ::impl<const field_indirect<T1,M>&, const field_component<T2,M>&>::result_type const
1628 >::type
1629 operator+ (const field_indirect<T1,M>& l, const field_component<T2,M>& r)
1630 {
1631  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1632  ::impl<const field_indirect<T1,M>&, const field_component<T2,M>&>() (l, r);
1633 }
1634 #else // BOOST_VERSION >= 104601
1635 typename boost::proto::detail::enable_binary<
1636  field_domain,
1637  field_domain::proto_grammar,
1638  boost::mpl::and_<
1639  boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_component<T2,M> > >,
1640  boost::mpl::not_<
1641  boost::mpl::or_<
1642  boost::proto::is_extension<field_indirect<T1,M> >,
1643  boost::proto::is_extension<field_component<T2,M> >
1644  >
1645  >
1646  >,
1647  boost::proto::tag::plus,
1648  field_indirect<T1,M> const &,
1649  field_component<T2,M> const &
1650 >::type /* const */
1651 operator+ (field_indirect<T1,M> const &left, field_component<T2,M> const &right)
1652 {
1653  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect<T1,M> const &, field_component<T2,M> const &>()(left, right);
1654 }
1655 #endif // BOOST_VERSION
1656 template<class T1, class T2, class M>
1657 #if BOOST_VERSION < 104601
1658 typename
1659 boost::proto::detail::enable_binary<
1660  field_domain,
1661  is_field<field_indirect<T1,M> >,
1662  field_indirect<T1,M>,
1663  is_field<field_component_const<T2,M> >,
1664  field_component_const<T2,M>,
1665  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1666  ::impl<const field_indirect<T1,M>&, const field_component_const<T2,M>&>::result_type const
1667 >::type
1668 operator+ (const field_indirect<T1,M>& l, const field_component_const<T2,M>& r)
1669 {
1670  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1671  ::impl<const field_indirect<T1,M>&, const field_component_const<T2,M>&>() (l, r);
1672 }
1673 #else // BOOST_VERSION >= 104601
1674 typename boost::proto::detail::enable_binary<
1675  field_domain,
1676  field_domain::proto_grammar,
1677  boost::mpl::and_<
1678  boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_component_const<T2,M> > >,
1679  boost::mpl::not_<
1680  boost::mpl::or_<
1681  boost::proto::is_extension<field_indirect<T1,M> >,
1682  boost::proto::is_extension<field_component_const<T2,M> >
1683  >
1684  >
1685  >,
1686  boost::proto::tag::plus,
1687  field_indirect<T1,M> const &,
1688  field_component_const<T2,M> const &
1689 >::type /* const */
1690 operator+ (field_indirect<T1,M> const &left, field_component_const<T2,M> const &right)
1691 {
1692  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
1693 }
1694 #endif // BOOST_VERSION
1695 template<class T1, class T2, class M>
1696 #if BOOST_VERSION < 104601
1697 typename
1698 boost::proto::detail::enable_binary<
1699  field_domain,
1700  is_field<field_indirect_const<T1,M> >,
1701  field_indirect_const<T1,M>,
1702  is_field<field_basic<T2,M> >,
1703  field_basic<T2,M>,
1704  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1705  ::impl<const field_indirect_const<T1,M>&, const field_basic<T2,M>&>::result_type const
1706 >::type
1707 operator+ (const field_indirect_const<T1,M>& l, const field_basic<T2,M>& r)
1708 {
1709  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1710  ::impl<const field_indirect_const<T1,M>&, const field_basic<T2,M>&>() (l, r);
1711 }
1712 #else // BOOST_VERSION >= 104601
1713 typename boost::proto::detail::enable_binary<
1714  field_domain,
1715  field_domain::proto_grammar,
1716  boost::mpl::and_<
1717  boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_basic<T2,M> > >,
1718  boost::mpl::not_<
1719  boost::mpl::or_<
1720  boost::proto::is_extension<field_indirect_const<T1,M> >,
1721  boost::proto::is_extension<field_basic<T2,M> >
1722  >
1723  >
1724  >,
1725  boost::proto::tag::plus,
1726  field_indirect_const<T1,M> const &,
1727  field_basic<T2,M> const &
1728 >::type /* const */
1729 operator+ (field_indirect_const<T1,M> const &left, field_basic<T2,M> const &right)
1730 {
1731  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect_const<T1,M> const &, field_basic<T2,M> const &>()(left, right);
1732 }
1733 #endif // BOOST_VERSION
1734 template<class T1, class T2, class M>
1735 #if BOOST_VERSION < 104601
1736 typename
1737 boost::proto::detail::enable_binary<
1738  field_domain,
1739  is_field<field_indirect_const<T1,M> >,
1740  field_indirect_const<T1,M>,
1741  is_field<field_indirect<T2,M> >,
1742  field_indirect<T2,M>,
1743  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1744  ::impl<const field_indirect_const<T1,M>&, const field_indirect<T2,M>&>::result_type const
1745 >::type
1746 operator+ (const field_indirect_const<T1,M>& l, const field_indirect<T2,M>& r)
1747 {
1748  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1749  ::impl<const field_indirect_const<T1,M>&, const field_indirect<T2,M>&>() (l, r);
1750 }
1751 #else // BOOST_VERSION >= 104601
1752 typename boost::proto::detail::enable_binary<
1753  field_domain,
1754  field_domain::proto_grammar,
1755  boost::mpl::and_<
1756  boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_indirect<T2,M> > >,
1757  boost::mpl::not_<
1758  boost::mpl::or_<
1759  boost::proto::is_extension<field_indirect_const<T1,M> >,
1760  boost::proto::is_extension<field_indirect<T2,M> >
1761  >
1762  >
1763  >,
1764  boost::proto::tag::plus,
1765  field_indirect_const<T1,M> const &,
1766  field_indirect<T2,M> const &
1767 >::type /* const */
1768 operator+ (field_indirect_const<T1,M> const &left, field_indirect<T2,M> const &right)
1769 {
1770  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect_const<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
1771 }
1772 #endif // BOOST_VERSION
1773 template<class T1, class T2, class M>
1774 #if BOOST_VERSION < 104601
1775 typename
1776 boost::proto::detail::enable_binary<
1777  field_domain,
1778  is_field<field_indirect_const<T1,M> >,
1779  field_indirect_const<T1,M>,
1780  is_field<field_indirect_const<T2,M> >,
1781  field_indirect_const<T2,M>,
1782  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1783  ::impl<const field_indirect_const<T1,M>&, const field_indirect_const<T2,M>&>::result_type const
1784 >::type
1785 operator+ (const field_indirect_const<T1,M>& l, const field_indirect_const<T2,M>& r)
1786 {
1787  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1788  ::impl<const field_indirect_const<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
1789 }
1790 #else // BOOST_VERSION >= 104601
1791 typename boost::proto::detail::enable_binary<
1792  field_domain,
1793  field_domain::proto_grammar,
1794  boost::mpl::and_<
1795  boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_indirect_const<T2,M> > >,
1796  boost::mpl::not_<
1797  boost::mpl::or_<
1798  boost::proto::is_extension<field_indirect_const<T1,M> >,
1799  boost::proto::is_extension<field_indirect_const<T2,M> >
1800  >
1801  >
1802  >,
1803  boost::proto::tag::plus,
1804  field_indirect_const<T1,M> const &,
1805  field_indirect_const<T2,M> const &
1806 >::type /* const */
1807 operator+ (field_indirect_const<T1,M> const &left, field_indirect_const<T2,M> const &right)
1808 {
1809  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect_const<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
1810 }
1811 #endif // BOOST_VERSION
1812 template<class T1, class T2, class M>
1813 #if BOOST_VERSION < 104601
1814 typename
1815 boost::proto::detail::enable_binary<
1816  field_domain,
1817  is_field<field_indirect_const<T1,M> >,
1818  field_indirect_const<T1,M>,
1819  is_field<field_component<T2,M> >,
1820  field_component<T2,M>,
1821  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1822  ::impl<const field_indirect_const<T1,M>&, const field_component<T2,M>&>::result_type const
1823 >::type
1824 operator+ (const field_indirect_const<T1,M>& l, const field_component<T2,M>& r)
1825 {
1826  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1827  ::impl<const field_indirect_const<T1,M>&, const field_component<T2,M>&>() (l, r);
1828 }
1829 #else // BOOST_VERSION >= 104601
1830 typename boost::proto::detail::enable_binary<
1831  field_domain,
1832  field_domain::proto_grammar,
1833  boost::mpl::and_<
1834  boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_component<T2,M> > >,
1835  boost::mpl::not_<
1836  boost::mpl::or_<
1837  boost::proto::is_extension<field_indirect_const<T1,M> >,
1838  boost::proto::is_extension<field_component<T2,M> >
1839  >
1840  >
1841  >,
1842  boost::proto::tag::plus,
1843  field_indirect_const<T1,M> const &,
1844  field_component<T2,M> const &
1845 >::type /* const */
1846 operator+ (field_indirect_const<T1,M> const &left, field_component<T2,M> const &right)
1847 {
1848  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect_const<T1,M> const &, field_component<T2,M> const &>()(left, right);
1849 }
1850 #endif // BOOST_VERSION
1851 template<class T1, class T2, class M>
1852 #if BOOST_VERSION < 104601
1853 typename
1854 boost::proto::detail::enable_binary<
1855  field_domain,
1856  is_field<field_indirect_const<T1,M> >,
1857  field_indirect_const<T1,M>,
1858  is_field<field_component_const<T2,M> >,
1859  field_component_const<T2,M>,
1860  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1861  ::impl<const field_indirect_const<T1,M>&, const field_component_const<T2,M>&>::result_type const
1862 >::type
1863 operator+ (const field_indirect_const<T1,M>& l, const field_component_const<T2,M>& r)
1864 {
1865  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1866  ::impl<const field_indirect_const<T1,M>&, const field_component_const<T2,M>&>() (l, r);
1867 }
1868 #else // BOOST_VERSION >= 104601
1869 typename boost::proto::detail::enable_binary<
1870  field_domain,
1871  field_domain::proto_grammar,
1872  boost::mpl::and_<
1873  boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_component_const<T2,M> > >,
1874  boost::mpl::not_<
1875  boost::mpl::or_<
1876  boost::proto::is_extension<field_indirect_const<T1,M> >,
1877  boost::proto::is_extension<field_component_const<T2,M> >
1878  >
1879  >
1880  >,
1881  boost::proto::tag::plus,
1882  field_indirect_const<T1,M> const &,
1883  field_component_const<T2,M> const &
1884 >::type /* const */
1885 operator+ (field_indirect_const<T1,M> const &left, field_component_const<T2,M> const &right)
1886 {
1887  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect_const<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
1888 }
1889 #endif // BOOST_VERSION
1890 template<class T1, class T2, class M>
1891 #if BOOST_VERSION < 104601
1892 typename
1893 boost::proto::detail::enable_binary<
1894  field_domain,
1895  is_field<field_component<T1,M> >,
1896  field_component<T1,M>,
1897  is_field<field_basic<T2,M> >,
1898  field_basic<T2,M>,
1899  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1900  ::impl<const field_component<T1,M>&, const field_basic<T2,M>&>::result_type const
1901 >::type
1902 operator+ (const field_component<T1,M>& l, const field_basic<T2,M>& r)
1903 {
1904  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1905  ::impl<const field_component<T1,M>&, const field_basic<T2,M>&>() (l, r);
1906 }
1907 #else // BOOST_VERSION >= 104601
1908 typename boost::proto::detail::enable_binary<
1909  field_domain,
1910  field_domain::proto_grammar,
1911  boost::mpl::and_<
1912  boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_basic<T2,M> > >,
1913  boost::mpl::not_<
1914  boost::mpl::or_<
1915  boost::proto::is_extension<field_component<T1,M> >,
1916  boost::proto::is_extension<field_basic<T2,M> >
1917  >
1918  >
1919  >,
1920  boost::proto::tag::plus,
1921  field_component<T1,M> const &,
1922  field_basic<T2,M> const &
1923 >::type /* const */
1924 operator+ (field_component<T1,M> const &left, field_basic<T2,M> const &right)
1925 {
1926  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component<T1,M> const &, field_basic<T2,M> const &>()(left, right);
1927 }
1928 #endif // BOOST_VERSION
1929 template<class T1, class T2, class M>
1930 #if BOOST_VERSION < 104601
1931 typename
1932 boost::proto::detail::enable_binary<
1933  field_domain,
1934  is_field<field_component<T1,M> >,
1935  field_component<T1,M>,
1936  is_field<field_indirect<T2,M> >,
1937  field_indirect<T2,M>,
1938  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1939  ::impl<const field_component<T1,M>&, const field_indirect<T2,M>&>::result_type const
1940 >::type
1941 operator+ (const field_component<T1,M>& l, const field_indirect<T2,M>& r)
1942 {
1943  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1944  ::impl<const field_component<T1,M>&, const field_indirect<T2,M>&>() (l, r);
1945 }
1946 #else // BOOST_VERSION >= 104601
1947 typename boost::proto::detail::enable_binary<
1948  field_domain,
1949  field_domain::proto_grammar,
1950  boost::mpl::and_<
1951  boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_indirect<T2,M> > >,
1952  boost::mpl::not_<
1953  boost::mpl::or_<
1954  boost::proto::is_extension<field_component<T1,M> >,
1955  boost::proto::is_extension<field_indirect<T2,M> >
1956  >
1957  >
1958  >,
1959  boost::proto::tag::plus,
1960  field_component<T1,M> const &,
1961  field_indirect<T2,M> const &
1962 >::type /* const */
1963 operator+ (field_component<T1,M> const &left, field_indirect<T2,M> const &right)
1964 {
1965  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
1966 }
1967 #endif // BOOST_VERSION
1968 template<class T1, class T2, class M>
1969 #if BOOST_VERSION < 104601
1970 typename
1971 boost::proto::detail::enable_binary<
1972  field_domain,
1973  is_field<field_component<T1,M> >,
1974  field_component<T1,M>,
1975  is_field<field_indirect_const<T2,M> >,
1976  field_indirect_const<T2,M>,
1977  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1978  ::impl<const field_component<T1,M>&, const field_indirect_const<T2,M>&>::result_type const
1979 >::type
1980 operator+ (const field_component<T1,M>& l, const field_indirect_const<T2,M>& r)
1981 {
1982  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
1983  ::impl<const field_component<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
1984 }
1985 #else // BOOST_VERSION >= 104601
1986 typename boost::proto::detail::enable_binary<
1987  field_domain,
1988  field_domain::proto_grammar,
1989  boost::mpl::and_<
1990  boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_indirect_const<T2,M> > >,
1991  boost::mpl::not_<
1992  boost::mpl::or_<
1993  boost::proto::is_extension<field_component<T1,M> >,
1994  boost::proto::is_extension<field_indirect_const<T2,M> >
1995  >
1996  >
1997  >,
1998  boost::proto::tag::plus,
1999  field_component<T1,M> const &,
2000  field_indirect_const<T2,M> const &
2001 >::type /* const */
2002 operator+ (field_component<T1,M> const &left, field_indirect_const<T2,M> const &right)
2003 {
2004  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
2005 }
2006 #endif // BOOST_VERSION
2007 template<class T1, class T2, class M>
2008 #if BOOST_VERSION < 104601
2009 typename
2010 boost::proto::detail::enable_binary<
2011  field_domain,
2012  is_field<field_component<T1,M> >,
2013  field_component<T1,M>,
2014  is_field<field_component<T2,M> >,
2015  field_component<T2,M>,
2016  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2017  ::impl<const field_component<T1,M>&, const field_component<T2,M>&>::result_type const
2018 >::type
2019 operator+ (const field_component<T1,M>& l, const field_component<T2,M>& r)
2020 {
2021  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2022  ::impl<const field_component<T1,M>&, const field_component<T2,M>&>() (l, r);
2023 }
2024 #else // BOOST_VERSION >= 104601
2025 typename boost::proto::detail::enable_binary<
2026  field_domain,
2027  field_domain::proto_grammar,
2028  boost::mpl::and_<
2029  boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_component<T2,M> > >,
2030  boost::mpl::not_<
2031  boost::mpl::or_<
2032  boost::proto::is_extension<field_component<T1,M> >,
2033  boost::proto::is_extension<field_component<T2,M> >
2034  >
2035  >
2036  >,
2037  boost::proto::tag::plus,
2038  field_component<T1,M> const &,
2039  field_component<T2,M> const &
2040 >::type /* const */
2041 operator+ (field_component<T1,M> const &left, field_component<T2,M> const &right)
2042 {
2043  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component<T1,M> const &, field_component<T2,M> const &>()(left, right);
2044 }
2045 #endif // BOOST_VERSION
2046 template<class T1, class T2, class M>
2047 #if BOOST_VERSION < 104601
2048 typename
2049 boost::proto::detail::enable_binary<
2050  field_domain,
2051  is_field<field_component<T1,M> >,
2052  field_component<T1,M>,
2053  is_field<field_component_const<T2,M> >,
2054  field_component_const<T2,M>,
2055  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2056  ::impl<const field_component<T1,M>&, const field_component_const<T2,M>&>::result_type const
2057 >::type
2058 operator+ (const field_component<T1,M>& l, const field_component_const<T2,M>& r)
2059 {
2060  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2061  ::impl<const field_component<T1,M>&, const field_component_const<T2,M>&>() (l, r);
2062 }
2063 #else // BOOST_VERSION >= 104601
2064 typename boost::proto::detail::enable_binary<
2065  field_domain,
2066  field_domain::proto_grammar,
2067  boost::mpl::and_<
2068  boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_component_const<T2,M> > >,
2069  boost::mpl::not_<
2070  boost::mpl::or_<
2071  boost::proto::is_extension<field_component<T1,M> >,
2072  boost::proto::is_extension<field_component_const<T2,M> >
2073  >
2074  >
2075  >,
2076  boost::proto::tag::plus,
2077  field_component<T1,M> const &,
2078  field_component_const<T2,M> const &
2079 >::type /* const */
2080 operator+ (field_component<T1,M> const &left, field_component_const<T2,M> const &right)
2081 {
2082  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
2083 }
2084 #endif // BOOST_VERSION
2085 template<class T1, class T2, class M>
2086 #if BOOST_VERSION < 104601
2087 typename
2088 boost::proto::detail::enable_binary<
2089  field_domain,
2090  is_field<field_component_const<T1,M> >,
2091  field_component_const<T1,M>,
2092  is_field<field_basic<T2,M> >,
2093  field_basic<T2,M>,
2094  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2095  ::impl<const field_component_const<T1,M>&, const field_basic<T2,M>&>::result_type const
2096 >::type
2097 operator+ (const field_component_const<T1,M>& l, const field_basic<T2,M>& r)
2098 {
2099  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2100  ::impl<const field_component_const<T1,M>&, const field_basic<T2,M>&>() (l, r);
2101 }
2102 #else // BOOST_VERSION >= 104601
2103 typename boost::proto::detail::enable_binary<
2104  field_domain,
2105  field_domain::proto_grammar,
2106  boost::mpl::and_<
2107  boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_basic<T2,M> > >,
2108  boost::mpl::not_<
2109  boost::mpl::or_<
2110  boost::proto::is_extension<field_component_const<T1,M> >,
2111  boost::proto::is_extension<field_basic<T2,M> >
2112  >
2113  >
2114  >,
2115  boost::proto::tag::plus,
2116  field_component_const<T1,M> const &,
2117  field_basic<T2,M> const &
2118 >::type /* const */
2119 operator+ (field_component_const<T1,M> const &left, field_basic<T2,M> const &right)
2120 {
2121  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component_const<T1,M> const &, field_basic<T2,M> const &>()(left, right);
2122 }
2123 #endif // BOOST_VERSION
2124 template<class T1, class T2, class M>
2125 #if BOOST_VERSION < 104601
2126 typename
2127 boost::proto::detail::enable_binary<
2128  field_domain,
2129  is_field<field_component_const<T1,M> >,
2130  field_component_const<T1,M>,
2131  is_field<field_indirect<T2,M> >,
2132  field_indirect<T2,M>,
2133  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2134  ::impl<const field_component_const<T1,M>&, const field_indirect<T2,M>&>::result_type const
2135 >::type
2136 operator+ (const field_component_const<T1,M>& l, const field_indirect<T2,M>& r)
2137 {
2138  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2139  ::impl<const field_component_const<T1,M>&, const field_indirect<T2,M>&>() (l, r);
2140 }
2141 #else // BOOST_VERSION >= 104601
2142 typename boost::proto::detail::enable_binary<
2143  field_domain,
2144  field_domain::proto_grammar,
2145  boost::mpl::and_<
2146  boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_indirect<T2,M> > >,
2147  boost::mpl::not_<
2148  boost::mpl::or_<
2149  boost::proto::is_extension<field_component_const<T1,M> >,
2150  boost::proto::is_extension<field_indirect<T2,M> >
2151  >
2152  >
2153  >,
2154  boost::proto::tag::plus,
2155  field_component_const<T1,M> const &,
2156  field_indirect<T2,M> const &
2157 >::type /* const */
2158 operator+ (field_component_const<T1,M> const &left, field_indirect<T2,M> const &right)
2159 {
2160  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component_const<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
2161 }
2162 #endif // BOOST_VERSION
2163 template<class T1, class T2, class M>
2164 #if BOOST_VERSION < 104601
2165 typename
2166 boost::proto::detail::enable_binary<
2167  field_domain,
2168  is_field<field_component_const<T1,M> >,
2169  field_component_const<T1,M>,
2170  is_field<field_indirect_const<T2,M> >,
2171  field_indirect_const<T2,M>,
2172  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2173  ::impl<const field_component_const<T1,M>&, const field_indirect_const<T2,M>&>::result_type const
2174 >::type
2175 operator+ (const field_component_const<T1,M>& l, const field_indirect_const<T2,M>& r)
2176 {
2177  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2178  ::impl<const field_component_const<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
2179 }
2180 #else // BOOST_VERSION >= 104601
2181 typename boost::proto::detail::enable_binary<
2182  field_domain,
2183  field_domain::proto_grammar,
2184  boost::mpl::and_<
2185  boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_indirect_const<T2,M> > >,
2186  boost::mpl::not_<
2187  boost::mpl::or_<
2188  boost::proto::is_extension<field_component_const<T1,M> >,
2189  boost::proto::is_extension<field_indirect_const<T2,M> >
2190  >
2191  >
2192  >,
2193  boost::proto::tag::plus,
2194  field_component_const<T1,M> const &,
2195  field_indirect_const<T2,M> const &
2196 >::type /* const */
2197 operator+ (field_component_const<T1,M> const &left, field_indirect_const<T2,M> const &right)
2198 {
2199  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component_const<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
2200 }
2201 #endif // BOOST_VERSION
2202 template<class T1, class T2, class M>
2203 #if BOOST_VERSION < 104601
2204 typename
2205 boost::proto::detail::enable_binary<
2206  field_domain,
2207  is_field<field_component_const<T1,M> >,
2208  field_component_const<T1,M>,
2209  is_field<field_component<T2,M> >,
2210  field_component<T2,M>,
2211  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2212  ::impl<const field_component_const<T1,M>&, const field_component<T2,M>&>::result_type const
2213 >::type
2214 operator+ (const field_component_const<T1,M>& l, const field_component<T2,M>& r)
2215 {
2216  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2217  ::impl<const field_component_const<T1,M>&, const field_component<T2,M>&>() (l, r);
2218 }
2219 #else // BOOST_VERSION >= 104601
2220 typename boost::proto::detail::enable_binary<
2221  field_domain,
2222  field_domain::proto_grammar,
2223  boost::mpl::and_<
2224  boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_component<T2,M> > >,
2225  boost::mpl::not_<
2226  boost::mpl::or_<
2227  boost::proto::is_extension<field_component_const<T1,M> >,
2228  boost::proto::is_extension<field_component<T2,M> >
2229  >
2230  >
2231  >,
2232  boost::proto::tag::plus,
2233  field_component_const<T1,M> const &,
2234  field_component<T2,M> const &
2235 >::type /* const */
2236 operator+ (field_component_const<T1,M> const &left, field_component<T2,M> const &right)
2237 {
2238  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component_const<T1,M> const &, field_component<T2,M> const &>()(left, right);
2239 }
2240 #endif // BOOST_VERSION
2241 template<class T1, class T2, class M>
2242 #if BOOST_VERSION < 104601
2243 typename
2244 boost::proto::detail::enable_binary<
2245  field_domain,
2246  is_field<field_component_const<T1,M> >,
2247  field_component_const<T1,M>,
2248  is_field<field_component_const<T2,M> >,
2249  field_component_const<T2,M>,
2250  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2251  ::impl<const field_component_const<T1,M>&, const field_component_const<T2,M>&>::result_type const
2252 >::type
2253 operator+ (const field_component_const<T1,M>& l, const field_component_const<T2,M>& r)
2254 {
2255  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2256  ::impl<const field_component_const<T1,M>&, const field_component_const<T2,M>&>() (l, r);
2257 }
2258 #else // BOOST_VERSION >= 104601
2259 typename boost::proto::detail::enable_binary<
2260  field_domain,
2261  field_domain::proto_grammar,
2262  boost::mpl::and_<
2263  boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_component_const<T2,M> > >,
2264  boost::mpl::not_<
2265  boost::mpl::or_<
2266  boost::proto::is_extension<field_component_const<T1,M> >,
2267  boost::proto::is_extension<field_component_const<T2,M> >
2268  >
2269  >
2270  >,
2271  boost::proto::tag::plus,
2272  field_component_const<T1,M> const &,
2273  field_component_const<T2,M> const &
2274 >::type /* const */
2275 operator+ (field_component_const<T1,M> const &left, field_component_const<T2,M> const &right)
2276 {
2277  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component_const<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
2278 }
2279 #endif // BOOST_VERSION
2280 template<class T, class M, class Expr>
2281 #if BOOST_VERSION < 104601
2282 typename
2283 boost::proto::detail::enable_binary<
2284  field_domain,
2285  is_field<field_basic<T,M> >,
2286  field_basic<T,M>,
2287  is_field<field_expr<Expr> >,
2288  field_expr<Expr>,
2289  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2290  ::impl<const field_basic<T,M>&, const field_expr<Expr>&>::result_type const
2291 >::type
2292 operator+ (const field_basic<T,M>& l, const field_expr<Expr>& r)
2293 {
2294  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2295  ::impl<const field_basic<T,M>&, const field_expr<Expr>&>() (l, r);
2296 }
2297 #else // BOOST_VERSION >= 104601
2298 typename boost::proto::detail::enable_binary<
2299  field_domain,
2300  field_domain::proto_grammar,
2301  boost::mpl::and_<
2302  boost::mpl::or_<is_field<field_basic<T,M> >, is_field<field_expr<Expr> > >,
2303  boost::mpl::not_<
2304  boost::mpl::or_<
2305  boost::proto::is_extension<field_basic<T,M> >,
2306  boost::proto::is_extension<field_expr<Expr> >
2307  >
2308  >
2309  >,
2310  boost::proto::tag::plus,
2311  field_basic<T,M> const &,
2312  field_expr<Expr> const &
2313 >::type /* const */
2314 operator+ (field_basic<T,M> const &left, field_expr<Expr> const &right)
2315 {
2316  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_basic<T,M> const &, field_expr<Expr> const &>()(left, right);
2317 }
2318 #endif // BOOST_VERSION
2319 template<class T, class M, class Expr>
2320 #if BOOST_VERSION < 104601
2321 typename
2322 boost::proto::detail::enable_binary<
2323  field_domain,
2324  is_field<field_expr<Expr> >,
2325  field_expr<Expr>,
2326  is_field<field_basic<T,M> >,
2327  field_basic<T,M>,
2328  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2329  ::impl<const field_expr<Expr>&, const field_basic<T,M>&>::result_type const
2330 >::type
2331 operator+ (const field_expr<Expr>& l, const field_basic<T,M>& r)
2332 {
2333  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2334  ::impl<const field_expr<Expr>&, const field_basic<T,M>&>() (l, r);
2335 }
2336 #else // BOOST_VERSION >= 104601
2337 typename boost::proto::detail::enable_binary<
2338  field_domain,
2339  field_domain::proto_grammar,
2340  boost::mpl::and_<
2341  boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_basic<T,M> > >,
2342  boost::mpl::not_<
2343  boost::mpl::or_<
2344  boost::proto::is_extension<field_expr<Expr> >,
2345  boost::proto::is_extension<field_basic<T,M> >
2346  >
2347  >
2348  >,
2349  boost::proto::tag::plus,
2350  field_expr<Expr> const &,
2351  field_basic<T,M> const &
2352 >::type /* const */
2353 operator+ (field_expr<Expr> const &left, field_basic<T,M> const &right)
2354 {
2355  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_expr<Expr> const &, field_basic<T,M> const &>()(left, right);
2356 }
2357 #endif // BOOST_VERSION
2358 template<class T, class M, class Expr>
2359 #if BOOST_VERSION < 104601
2360 typename
2361 boost::proto::detail::enable_binary<
2362  field_domain,
2363  is_field<field_indirect<T,M> >,
2364  field_indirect<T,M>,
2365  is_field<field_expr<Expr> >,
2366  field_expr<Expr>,
2367  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2368  ::impl<const field_indirect<T,M>&, const field_expr<Expr>&>::result_type const
2369 >::type
2370 operator+ (const field_indirect<T,M>& l, const field_expr<Expr>& r)
2371 {
2372  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2373  ::impl<const field_indirect<T,M>&, const field_expr<Expr>&>() (l, r);
2374 }
2375 #else // BOOST_VERSION >= 104601
2376 typename boost::proto::detail::enable_binary<
2377  field_domain,
2378  field_domain::proto_grammar,
2379  boost::mpl::and_<
2380  boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<field_expr<Expr> > >,
2381  boost::mpl::not_<
2382  boost::mpl::or_<
2383  boost::proto::is_extension<field_indirect<T,M> >,
2384  boost::proto::is_extension<field_expr<Expr> >
2385  >
2386  >
2387  >,
2388  boost::proto::tag::plus,
2389  field_indirect<T,M> const &,
2390  field_expr<Expr> const &
2391 >::type /* const */
2392 operator+ (field_indirect<T,M> const &left, field_expr<Expr> const &right)
2393 {
2394  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect<T,M> const &, field_expr<Expr> const &>()(left, right);
2395 }
2396 #endif // BOOST_VERSION
2397 template<class T, class M, class Expr>
2398 #if BOOST_VERSION < 104601
2399 typename
2400 boost::proto::detail::enable_binary<
2401  field_domain,
2402  is_field<field_expr<Expr> >,
2403  field_expr<Expr>,
2404  is_field<field_indirect<T,M> >,
2405  field_indirect<T,M>,
2406  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2407  ::impl<const field_expr<Expr>&, const field_indirect<T,M>&>::result_type const
2408 >::type
2409 operator+ (const field_expr<Expr>& l, const field_indirect<T,M>& r)
2410 {
2411  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2412  ::impl<const field_expr<Expr>&, const field_indirect<T,M>&>() (l, r);
2413 }
2414 #else // BOOST_VERSION >= 104601
2415 typename boost::proto::detail::enable_binary<
2416  field_domain,
2417  field_domain::proto_grammar,
2418  boost::mpl::and_<
2419  boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_indirect<T,M> > >,
2420  boost::mpl::not_<
2421  boost::mpl::or_<
2422  boost::proto::is_extension<field_expr<Expr> >,
2423  boost::proto::is_extension<field_indirect<T,M> >
2424  >
2425  >
2426  >,
2427  boost::proto::tag::plus,
2428  field_expr<Expr> const &,
2429  field_indirect<T,M> const &
2430 >::type /* const */
2431 operator+ (field_expr<Expr> const &left, field_indirect<T,M> const &right)
2432 {
2433  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_expr<Expr> const &, field_indirect<T,M> const &>()(left, right);
2434 }
2435 #endif // BOOST_VERSION
2436 template<class T, class M, class Expr>
2437 #if BOOST_VERSION < 104601
2438 typename
2439 boost::proto::detail::enable_binary<
2440  field_domain,
2441  is_field<field_indirect_const<T,M> >,
2442  field_indirect_const<T,M>,
2443  is_field<field_expr<Expr> >,
2444  field_expr<Expr>,
2445  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2446  ::impl<const field_indirect_const<T,M>&, const field_expr<Expr>&>::result_type const
2447 >::type
2448 operator+ (const field_indirect_const<T,M>& l, const field_expr<Expr>& r)
2449 {
2450  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2451  ::impl<const field_indirect_const<T,M>&, const field_expr<Expr>&>() (l, r);
2452 }
2453 #else // BOOST_VERSION >= 104601
2454 typename boost::proto::detail::enable_binary<
2455  field_domain,
2456  field_domain::proto_grammar,
2457  boost::mpl::and_<
2458  boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<field_expr<Expr> > >,
2459  boost::mpl::not_<
2460  boost::mpl::or_<
2461  boost::proto::is_extension<field_indirect_const<T,M> >,
2462  boost::proto::is_extension<field_expr<Expr> >
2463  >
2464  >
2465  >,
2466  boost::proto::tag::plus,
2467  field_indirect_const<T,M> const &,
2468  field_expr<Expr> const &
2469 >::type /* const */
2470 operator+ (field_indirect_const<T,M> const &left, field_expr<Expr> const &right)
2471 {
2472  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_indirect_const<T,M> const &, field_expr<Expr> const &>()(left, right);
2473 }
2474 #endif // BOOST_VERSION
2475 template<class T, class M, class Expr>
2476 #if BOOST_VERSION < 104601
2477 typename
2478 boost::proto::detail::enable_binary<
2479  field_domain,
2480  is_field<field_expr<Expr> >,
2481  field_expr<Expr>,
2482  is_field<field_indirect_const<T,M> >,
2483  field_indirect_const<T,M>,
2484  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2485  ::impl<const field_expr<Expr>&, const field_indirect_const<T,M>&>::result_type const
2486 >::type
2487 operator+ (const field_expr<Expr>& l, const field_indirect_const<T,M>& r)
2488 {
2489  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2490  ::impl<const field_expr<Expr>&, const field_indirect_const<T,M>&>() (l, r);
2491 }
2492 #else // BOOST_VERSION >= 104601
2493 typename boost::proto::detail::enable_binary<
2494  field_domain,
2495  field_domain::proto_grammar,
2496  boost::mpl::and_<
2497  boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_indirect_const<T,M> > >,
2498  boost::mpl::not_<
2499  boost::mpl::or_<
2500  boost::proto::is_extension<field_expr<Expr> >,
2501  boost::proto::is_extension<field_indirect_const<T,M> >
2502  >
2503  >
2504  >,
2505  boost::proto::tag::plus,
2506  field_expr<Expr> const &,
2507  field_indirect_const<T,M> const &
2508 >::type /* const */
2509 operator+ (field_expr<Expr> const &left, field_indirect_const<T,M> const &right)
2510 {
2511  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_expr<Expr> const &, field_indirect_const<T,M> const &>()(left, right);
2512 }
2513 #endif // BOOST_VERSION
2514 template<class T, class M, class Expr>
2515 #if BOOST_VERSION < 104601
2516 typename
2517 boost::proto::detail::enable_binary<
2518  field_domain,
2519  is_field<field_component<T,M> >,
2520  field_component<T,M>,
2521  is_field<field_expr<Expr> >,
2522  field_expr<Expr>,
2523  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2524  ::impl<const field_component<T,M>&, const field_expr<Expr>&>::result_type const
2525 >::type
2526 operator+ (const field_component<T,M>& l, const field_expr<Expr>& r)
2527 {
2528  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2529  ::impl<const field_component<T,M>&, const field_expr<Expr>&>() (l, r);
2530 }
2531 #else // BOOST_VERSION >= 104601
2532 typename boost::proto::detail::enable_binary<
2533  field_domain,
2534  field_domain::proto_grammar,
2535  boost::mpl::and_<
2536  boost::mpl::or_<is_field<field_component<T,M> >, is_field<field_expr<Expr> > >,
2537  boost::mpl::not_<
2538  boost::mpl::or_<
2539  boost::proto::is_extension<field_component<T,M> >,
2540  boost::proto::is_extension<field_expr<Expr> >
2541  >
2542  >
2543  >,
2544  boost::proto::tag::plus,
2545  field_component<T,M> const &,
2546  field_expr<Expr> const &
2547 >::type /* const */
2548 operator+ (field_component<T,M> const &left, field_expr<Expr> const &right)
2549 {
2550  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component<T,M> const &, field_expr<Expr> const &>()(left, right);
2551 }
2552 #endif // BOOST_VERSION
2553 template<class T, class M, class Expr>
2554 #if BOOST_VERSION < 104601
2555 typename
2556 boost::proto::detail::enable_binary<
2557  field_domain,
2558  is_field<field_expr<Expr> >,
2559  field_expr<Expr>,
2560  is_field<field_component<T,M> >,
2561  field_component<T,M>,
2562  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2563  ::impl<const field_expr<Expr>&, const field_component<T,M>&>::result_type const
2564 >::type
2565 operator+ (const field_expr<Expr>& l, const field_component<T,M>& r)
2566 {
2567  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2568  ::impl<const field_expr<Expr>&, const field_component<T,M>&>() (l, r);
2569 }
2570 #else // BOOST_VERSION >= 104601
2571 typename boost::proto::detail::enable_binary<
2572  field_domain,
2573  field_domain::proto_grammar,
2574  boost::mpl::and_<
2575  boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_component<T,M> > >,
2576  boost::mpl::not_<
2577  boost::mpl::or_<
2578  boost::proto::is_extension<field_expr<Expr> >,
2579  boost::proto::is_extension<field_component<T,M> >
2580  >
2581  >
2582  >,
2583  boost::proto::tag::plus,
2584  field_expr<Expr> const &,
2585  field_component<T,M> const &
2586 >::type /* const */
2587 operator+ (field_expr<Expr> const &left, field_component<T,M> const &right)
2588 {
2589  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_expr<Expr> const &, field_component<T,M> const &>()(left, right);
2590 }
2591 #endif // BOOST_VERSION
2592 template<class T, class M, class Expr>
2593 #if BOOST_VERSION < 104601
2594 typename
2595 boost::proto::detail::enable_binary<
2596  field_domain,
2597  is_field<field_component_const<T,M> >,
2598  field_component_const<T,M>,
2599  is_field<field_expr<Expr> >,
2600  field_expr<Expr>,
2601  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2602  ::impl<const field_component_const<T,M>&, const field_expr<Expr>&>::result_type const
2603 >::type
2604 operator+ (const field_component_const<T,M>& l, const field_expr<Expr>& r)
2605 {
2606  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2607  ::impl<const field_component_const<T,M>&, const field_expr<Expr>&>() (l, r);
2608 }
2609 #else // BOOST_VERSION >= 104601
2610 typename boost::proto::detail::enable_binary<
2611  field_domain,
2612  field_domain::proto_grammar,
2613  boost::mpl::and_<
2614  boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<field_expr<Expr> > >,
2615  boost::mpl::not_<
2616  boost::mpl::or_<
2617  boost::proto::is_extension<field_component_const<T,M> >,
2618  boost::proto::is_extension<field_expr<Expr> >
2619  >
2620  >
2621  >,
2622  boost::proto::tag::plus,
2623  field_component_const<T,M> const &,
2624  field_expr<Expr> const &
2625 >::type /* const */
2626 operator+ (field_component_const<T,M> const &left, field_expr<Expr> const &right)
2627 {
2628  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_component_const<T,M> const &, field_expr<Expr> const &>()(left, right);
2629 }
2630 #endif // BOOST_VERSION
2631 template<class T, class M, class Expr>
2632 #if BOOST_VERSION < 104601
2633 typename
2634 boost::proto::detail::enable_binary<
2635  field_domain,
2636  is_field<field_expr<Expr> >,
2637  field_expr<Expr>,
2638  is_field<field_component_const<T,M> >,
2639  field_component_const<T,M>,
2640  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2641  ::impl<const field_expr<Expr>&, const field_component_const<T,M>&>::result_type const
2642 >::type
2643 operator+ (const field_expr<Expr>& l, const field_component_const<T,M>& r)
2644 {
2645  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2646  ::impl<const field_expr<Expr>&, const field_component_const<T,M>&>() (l, r);
2647 }
2648 #else // BOOST_VERSION >= 104601
2649 typename boost::proto::detail::enable_binary<
2650  field_domain,
2651  field_domain::proto_grammar,
2652  boost::mpl::and_<
2653  boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_component_const<T,M> > >,
2654  boost::mpl::not_<
2655  boost::mpl::or_<
2656  boost::proto::is_extension<field_expr<Expr> >,
2657  boost::proto::is_extension<field_component_const<T,M> >
2658  >
2659  >
2660  >,
2661  boost::proto::tag::plus,
2662  field_expr<Expr> const &,
2663  field_component_const<T,M> const &
2664 >::type /* const */
2665 operator+ (field_expr<Expr> const &left, field_component_const<T,M> const &right)
2666 {
2667  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_expr<Expr> const &, field_component_const<T,M> const &>()(left, right);
2668 }
2669 #endif // BOOST_VERSION
2670 template<class Expr1, class Expr2>
2671 #if BOOST_VERSION < 104601
2672 typename
2673 boost::proto::detail::enable_binary<
2674  field_domain,
2675  is_field<field_expr<Expr1> >,
2676  field_expr<Expr1>,
2677  is_field<field_expr<Expr2> >,
2678  field_expr<Expr2>,
2679  typename boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2680  ::impl<const field_expr<Expr1>&, const field_expr<Expr2>&>::result_type const
2681 >::type
2682 operator+ (const field_expr<Expr1>& l, const field_expr<Expr2>& r)
2683 {
2684  return boost::proto::functional::make_expr<boost::proto::tag::plus, field_domain>
2685  ::impl<const field_expr<Expr1>&, const field_expr<Expr2>&>() (l, r);
2686 }
2687 #else // BOOST_VERSION >= 104601
2688 typename boost::proto::detail::enable_binary<
2689  field_domain,
2690  field_domain::proto_grammar,
2691  boost::mpl::and_<
2692  boost::mpl::or_<is_field<field_expr<Expr1> >, is_field<field_expr<Expr2> > >,
2693  boost::mpl::not_<
2694  boost::mpl::or_<
2695  boost::proto::is_extension<field_expr<Expr1> >,
2696  boost::proto::is_extension<field_expr<Expr2> >
2697  >
2698  >
2699  >,
2700  boost::proto::tag::plus,
2701  field_expr<Expr1> const &,
2702  field_expr<Expr2> const &
2703 >::type /* const */
2704 operator+ (field_expr<Expr1> const &left, field_expr<Expr2> const &right)
2705 {
2706  return boost::proto::detail::make_expr_<boost::proto::tag::plus, field_domain, field_expr<Expr1> const &, field_expr<Expr2> const &>()(left, right);
2707 }
2708 #endif // BOOST_VERSION
2709 template<class T, class M>
2710 #if BOOST_VERSION < 104601
2711 typename
2712 boost::proto::detail::enable_binary<
2713  field_domain,
2714  is_field<int >,
2715  int,
2716  is_field<field_basic<T,M> >,
2717  field_basic<T,M>,
2718  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
2719  ::impl<const int&, const field_basic<T,M>&>::result_type const
2720 >::type
2721 operator- (const int& l, const field_basic<T,M>& r)
2722 {
2723  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
2724  ::impl<const int&, const field_basic<T,M>&>() (l, r);
2725 }
2726 #else // BOOST_VERSION >= 104601
2727 typename boost::proto::detail::enable_binary<
2728  field_domain,
2729  field_domain::proto_grammar,
2730  boost::mpl::and_<
2731  boost::mpl::or_<is_field<int >, is_field<field_basic<T,M> > >,
2732  boost::mpl::not_<
2733  boost::mpl::or_<
2734  boost::proto::is_extension<int >,
2735  boost::proto::is_extension<field_basic<T,M> >
2736  >
2737  >
2738  >,
2739  boost::proto::tag::minus,
2740  int const &,
2741  field_basic<T,M> const &
2742 >::type /* const */
2743 operator- (int const &left, field_basic<T,M> const &right)
2744 {
2745  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, int const &, field_basic<T,M> const &>()(left, right);
2746 }
2747 #endif // BOOST_VERSION
2748 template<class T, class M>
2749 #if BOOST_VERSION < 104601
2750 typename
2751 boost::proto::detail::enable_binary<
2752  field_domain,
2753  is_field<T >,
2754  T,
2755  is_field<field_basic<T,M> >,
2756  field_basic<T,M>,
2757  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
2758  ::impl<const T&, const field_basic<T,M>&>::result_type const
2759 >::type
2760 operator- (const T& l, const field_basic<T,M>& r)
2761 {
2762  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
2763  ::impl<const T&, const field_basic<T,M>&>() (l, r);
2764 }
2765 #else // BOOST_VERSION >= 104601
2766 typename boost::proto::detail::enable_binary<
2767  field_domain,
2768  field_domain::proto_grammar,
2769  boost::mpl::and_<
2770  boost::mpl::or_<is_field<T >, is_field<field_basic<T,M> > >,
2771  boost::mpl::not_<
2772  boost::mpl::or_<
2773  boost::proto::is_extension<T >,
2774  boost::proto::is_extension<field_basic<T,M> >
2775  >
2776  >
2777  >,
2778  boost::proto::tag::minus,
2779  T const &,
2780  field_basic<T,M> const &
2781 >::type /* const */
2782 operator- (T const &left, field_basic<T,M> const &right)
2783 {
2784  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, T const &, field_basic<T,M> const &>()(left, right);
2785 }
2786 #endif // BOOST_VERSION
2787 template<class T, class M>
2788 #if BOOST_VERSION < 104601
2789 typename
2790 boost::proto::detail::enable_binary<
2791  field_domain,
2792  is_field<int >,
2793  int,
2794  is_field<field_indirect<T,M> >,
2795  field_indirect<T,M>,
2796  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
2797  ::impl<const int&, const field_indirect<T,M>&>::result_type const
2798 >::type
2799 operator- (const int& l, const field_indirect<T,M>& r)
2800 {
2801  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
2802  ::impl<const int&, const field_indirect<T,M>&>() (l, r);
2803 }
2804 #else // BOOST_VERSION >= 104601
2805 typename boost::proto::detail::enable_binary<
2806  field_domain,
2807  field_domain::proto_grammar,
2808  boost::mpl::and_<
2809  boost::mpl::or_<is_field<int >, is_field<field_indirect<T,M> > >,
2810  boost::mpl::not_<
2811  boost::mpl::or_<
2812  boost::proto::is_extension<int >,
2813  boost::proto::is_extension<field_indirect<T,M> >
2814  >
2815  >
2816  >,
2817  boost::proto::tag::minus,
2818  int const &,
2819  field_indirect<T,M> const &
2820 >::type /* const */
2821 operator- (int const &left, field_indirect<T,M> const &right)
2822 {
2823  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, int const &, field_indirect<T,M> const &>()(left, right);
2824 }
2825 #endif // BOOST_VERSION
2826 template<class T, class M>
2827 #if BOOST_VERSION < 104601
2828 typename
2829 boost::proto::detail::enable_binary<
2830  field_domain,
2831  is_field<T >,
2832  T,
2833  is_field<field_indirect<T,M> >,
2834  field_indirect<T,M>,
2835  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
2836  ::impl<const T&, const field_indirect<T,M>&>::result_type const
2837 >::type
2838 operator- (const T& l, const field_indirect<T,M>& r)
2839 {
2840  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
2841  ::impl<const T&, const field_indirect<T,M>&>() (l, r);
2842 }
2843 #else // BOOST_VERSION >= 104601
2844 typename boost::proto::detail::enable_binary<
2845  field_domain,
2846  field_domain::proto_grammar,
2847  boost::mpl::and_<
2848  boost::mpl::or_<is_field<T >, is_field<field_indirect<T,M> > >,
2849  boost::mpl::not_<
2850  boost::mpl::or_<
2851  boost::proto::is_extension<T >,
2852  boost::proto::is_extension<field_indirect<T,M> >
2853  >
2854  >
2855  >,
2856  boost::proto::tag::minus,
2857  T const &,
2858  field_indirect<T,M> const &
2859 >::type /* const */
2860 operator- (T const &left, field_indirect<T,M> const &right)
2861 {
2862  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, T const &, field_indirect<T,M> const &>()(left, right);
2863 }
2864 #endif // BOOST_VERSION
2865 template<class T, class M>
2866 #if BOOST_VERSION < 104601
2867 typename
2868 boost::proto::detail::enable_binary<
2869  field_domain,
2870  is_field<int >,
2871  int,
2872  is_field<field_indirect_const<T,M> >,
2873  field_indirect_const<T,M>,
2874  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
2875  ::impl<const int&, const field_indirect_const<T,M>&>::result_type const
2876 >::type
2877 operator- (const int& l, const field_indirect_const<T,M>& r)
2878 {
2879  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
2880  ::impl<const int&, const field_indirect_const<T,M>&>() (l, r);
2881 }
2882 #else // BOOST_VERSION >= 104601
2883 typename boost::proto::detail::enable_binary<
2884  field_domain,
2885  field_domain::proto_grammar,
2886  boost::mpl::and_<
2887  boost::mpl::or_<is_field<int >, is_field<field_indirect_const<T,M> > >,
2888  boost::mpl::not_<
2889  boost::mpl::or_<
2890  boost::proto::is_extension<int >,
2891  boost::proto::is_extension<field_indirect_const<T,M> >
2892  >
2893  >
2894  >,
2895  boost::proto::tag::minus,
2896  int const &,
2897  field_indirect_const<T,M> const &
2898 >::type /* const */
2899 operator- (int const &left, field_indirect_const<T,M> const &right)
2900 {
2901  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, int const &, field_indirect_const<T,M> const &>()(left, right);
2902 }
2903 #endif // BOOST_VERSION
2904 template<class T, class M>
2905 #if BOOST_VERSION < 104601
2906 typename
2907 boost::proto::detail::enable_binary<
2908  field_domain,
2909  is_field<T >,
2910  T,
2911  is_field<field_indirect_const<T,M> >,
2912  field_indirect_const<T,M>,
2913  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
2914  ::impl<const T&, const field_indirect_const<T,M>&>::result_type const
2915 >::type
2916 operator- (const T& l, const field_indirect_const<T,M>& r)
2917 {
2918  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
2919  ::impl<const T&, const field_indirect_const<T,M>&>() (l, r);
2920 }
2921 #else // BOOST_VERSION >= 104601
2922 typename boost::proto::detail::enable_binary<
2923  field_domain,
2924  field_domain::proto_grammar,
2925  boost::mpl::and_<
2926  boost::mpl::or_<is_field<T >, is_field<field_indirect_const<T,M> > >,
2927  boost::mpl::not_<
2928  boost::mpl::or_<
2929  boost::proto::is_extension<T >,
2930  boost::proto::is_extension<field_indirect_const<T,M> >
2931  >
2932  >
2933  >,
2934  boost::proto::tag::minus,
2935  T const &,
2936  field_indirect_const<T,M> const &
2937 >::type /* const */
2938 operator- (T const &left, field_indirect_const<T,M> const &right)
2939 {
2940  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, T const &, field_indirect_const<T,M> const &>()(left, right);
2941 }
2942 #endif // BOOST_VERSION
2943 template<class T, class M>
2944 #if BOOST_VERSION < 104601
2945 typename
2946 boost::proto::detail::enable_binary<
2947  field_domain,
2948  is_field<int >,
2949  int,
2950  is_field<field_component<T,M> >,
2951  field_component<T,M>,
2952  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
2953  ::impl<const int&, const field_component<T,M>&>::result_type const
2954 >::type
2955 operator- (const int& l, const field_component<T,M>& r)
2956 {
2957  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
2958  ::impl<const int&, const field_component<T,M>&>() (l, r);
2959 }
2960 #else // BOOST_VERSION >= 104601
2961 typename boost::proto::detail::enable_binary<
2962  field_domain,
2963  field_domain::proto_grammar,
2964  boost::mpl::and_<
2965  boost::mpl::or_<is_field<int >, is_field<field_component<T,M> > >,
2966  boost::mpl::not_<
2967  boost::mpl::or_<
2968  boost::proto::is_extension<int >,
2969  boost::proto::is_extension<field_component<T,M> >
2970  >
2971  >
2972  >,
2973  boost::proto::tag::minus,
2974  int const &,
2975  field_component<T,M> const &
2976 >::type /* const */
2977 operator- (int const &left, field_component<T,M> const &right)
2978 {
2979  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, int const &, field_component<T,M> const &>()(left, right);
2980 }
2981 #endif // BOOST_VERSION
2982 template<class T, class M>
2983 #if BOOST_VERSION < 104601
2984 typename
2985 boost::proto::detail::enable_binary<
2986  field_domain,
2987  is_field<T >,
2988  T,
2989  is_field<field_component<T,M> >,
2990  field_component<T,M>,
2991  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
2992  ::impl<const T&, const field_component<T,M>&>::result_type const
2993 >::type
2994 operator- (const T& l, const field_component<T,M>& r)
2995 {
2996  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
2997  ::impl<const T&, const field_component<T,M>&>() (l, r);
2998 }
2999 #else // BOOST_VERSION >= 104601
3000 typename boost::proto::detail::enable_binary<
3001  field_domain,
3002  field_domain::proto_grammar,
3003  boost::mpl::and_<
3004  boost::mpl::or_<is_field<T >, is_field<field_component<T,M> > >,
3005  boost::mpl::not_<
3006  boost::mpl::or_<
3007  boost::proto::is_extension<T >,
3008  boost::proto::is_extension<field_component<T,M> >
3009  >
3010  >
3011  >,
3012  boost::proto::tag::minus,
3013  T const &,
3014  field_component<T,M> const &
3015 >::type /* const */
3016 operator- (T const &left, field_component<T,M> const &right)
3017 {
3018  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, T const &, field_component<T,M> const &>()(left, right);
3019 }
3020 #endif // BOOST_VERSION
3021 template<class T, class M>
3022 #if BOOST_VERSION < 104601
3023 typename
3024 boost::proto::detail::enable_binary<
3025  field_domain,
3026  is_field<int >,
3027  int,
3028  is_field<field_component_const<T,M> >,
3029  field_component_const<T,M>,
3030  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3031  ::impl<const int&, const field_component_const<T,M>&>::result_type const
3032 >::type
3033 operator- (const int& l, const field_component_const<T,M>& r)
3034 {
3035  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3036  ::impl<const int&, const field_component_const<T,M>&>() (l, r);
3037 }
3038 #else // BOOST_VERSION >= 104601
3039 typename boost::proto::detail::enable_binary<
3040  field_domain,
3041  field_domain::proto_grammar,
3042  boost::mpl::and_<
3043  boost::mpl::or_<is_field<int >, is_field<field_component_const<T,M> > >,
3044  boost::mpl::not_<
3045  boost::mpl::or_<
3046  boost::proto::is_extension<int >,
3047  boost::proto::is_extension<field_component_const<T,M> >
3048  >
3049  >
3050  >,
3051  boost::proto::tag::minus,
3052  int const &,
3053  field_component_const<T,M> const &
3054 >::type /* const */
3055 operator- (int const &left, field_component_const<T,M> const &right)
3056 {
3057  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, int const &, field_component_const<T,M> const &>()(left, right);
3058 }
3059 #endif // BOOST_VERSION
3060 template<class T, class M>
3061 #if BOOST_VERSION < 104601
3062 typename
3063 boost::proto::detail::enable_binary<
3064  field_domain,
3065  is_field<T >,
3066  T,
3067  is_field<field_component_const<T,M> >,
3068  field_component_const<T,M>,
3069  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3070  ::impl<const T&, const field_component_const<T,M>&>::result_type const
3071 >::type
3072 operator- (const T& l, const field_component_const<T,M>& r)
3073 {
3074  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3075  ::impl<const T&, const field_component_const<T,M>&>() (l, r);
3076 }
3077 #else // BOOST_VERSION >= 104601
3078 typename boost::proto::detail::enable_binary<
3079  field_domain,
3080  field_domain::proto_grammar,
3081  boost::mpl::and_<
3082  boost::mpl::or_<is_field<T >, is_field<field_component_const<T,M> > >,
3083  boost::mpl::not_<
3084  boost::mpl::or_<
3085  boost::proto::is_extension<T >,
3086  boost::proto::is_extension<field_component_const<T,M> >
3087  >
3088  >
3089  >,
3090  boost::proto::tag::minus,
3091  T const &,
3092  field_component_const<T,M> const &
3093 >::type /* const */
3094 operator- (T const &left, field_component_const<T,M> const &right)
3095 {
3096  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, T const &, field_component_const<T,M> const &>()(left, right);
3097 }
3098 #endif // BOOST_VERSION
3099 template<class T, class M>
3100 #if BOOST_VERSION < 104601
3101 typename
3102 boost::proto::detail::enable_binary<
3103  field_domain,
3104  is_field<field_basic<T,M> >,
3105  field_basic<T,M>,
3106  is_field<int >,
3107  int,
3108  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3109  ::impl<const field_basic<T,M>&, const int&>::result_type const
3110 >::type
3111 operator- (const field_basic<T,M>& l, const int& r)
3112 {
3113  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3114  ::impl<const field_basic<T,M>&, const int&>() (l, r);
3115 }
3116 #else // BOOST_VERSION >= 104601
3117 typename boost::proto::detail::enable_binary<
3118  field_domain,
3119  field_domain::proto_grammar,
3120  boost::mpl::and_<
3121  boost::mpl::or_<is_field<field_basic<T,M> >, is_field<int > >,
3122  boost::mpl::not_<
3123  boost::mpl::or_<
3124  boost::proto::is_extension<field_basic<T,M> >,
3125  boost::proto::is_extension<int >
3126  >
3127  >
3128  >,
3129  boost::proto::tag::minus,
3130  field_basic<T,M> const &,
3131  int const &
3132 >::type /* const */
3133 operator- (field_basic<T,M> const &left, int const &right)
3134 {
3135  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_basic<T,M> const &, int const &>()(left, right);
3136 }
3137 #endif // BOOST_VERSION
3138 template<class T, class M>
3139 #if BOOST_VERSION < 104601
3140 typename
3141 boost::proto::detail::enable_binary<
3142  field_domain,
3143  is_field<field_basic<T,M> >,
3144  field_basic<T,M>,
3145  is_field<T >,
3146  T,
3147  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3148  ::impl<const field_basic<T,M>&, const T&>::result_type const
3149 >::type
3150 operator- (const field_basic<T,M>& l, const T& r)
3151 {
3152  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3153  ::impl<const field_basic<T,M>&, const T&>() (l, r);
3154 }
3155 #else // BOOST_VERSION >= 104601
3156 typename boost::proto::detail::enable_binary<
3157  field_domain,
3158  field_domain::proto_grammar,
3159  boost::mpl::and_<
3160  boost::mpl::or_<is_field<field_basic<T,M> >, is_field<T > >,
3161  boost::mpl::not_<
3162  boost::mpl::or_<
3163  boost::proto::is_extension<field_basic<T,M> >,
3164  boost::proto::is_extension<T >
3165  >
3166  >
3167  >,
3168  boost::proto::tag::minus,
3169  field_basic<T,M> const &,
3170  T const &
3171 >::type /* const */
3172 operator- (field_basic<T,M> const &left, T const &right)
3173 {
3174  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_basic<T,M> const &, T const &>()(left, right);
3175 }
3176 #endif // BOOST_VERSION
3177 template<class T, class M>
3178 #if BOOST_VERSION < 104601
3179 typename
3180 boost::proto::detail::enable_binary<
3181  field_domain,
3182  is_field<field_indirect<T,M> >,
3183  field_indirect<T,M>,
3184  is_field<int >,
3185  int,
3186  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3187  ::impl<const field_indirect<T,M>&, const int&>::result_type const
3188 >::type
3189 operator- (const field_indirect<T,M>& l, const int& r)
3190 {
3191  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3192  ::impl<const field_indirect<T,M>&, const int&>() (l, r);
3193 }
3194 #else // BOOST_VERSION >= 104601
3195 typename boost::proto::detail::enable_binary<
3196  field_domain,
3197  field_domain::proto_grammar,
3198  boost::mpl::and_<
3199  boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<int > >,
3200  boost::mpl::not_<
3201  boost::mpl::or_<
3202  boost::proto::is_extension<field_indirect<T,M> >,
3203  boost::proto::is_extension<int >
3204  >
3205  >
3206  >,
3207  boost::proto::tag::minus,
3208  field_indirect<T,M> const &,
3209  int const &
3210 >::type /* const */
3211 operator- (field_indirect<T,M> const &left, int const &right)
3212 {
3213  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect<T,M> const &, int const &>()(left, right);
3214 }
3215 #endif // BOOST_VERSION
3216 template<class T, class M>
3217 #if BOOST_VERSION < 104601
3218 typename
3219 boost::proto::detail::enable_binary<
3220  field_domain,
3221  is_field<field_indirect<T,M> >,
3222  field_indirect<T,M>,
3223  is_field<T >,
3224  T,
3225  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3226  ::impl<const field_indirect<T,M>&, const T&>::result_type const
3227 >::type
3228 operator- (const field_indirect<T,M>& l, const T& r)
3229 {
3230  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3231  ::impl<const field_indirect<T,M>&, const T&>() (l, r);
3232 }
3233 #else // BOOST_VERSION >= 104601
3234 typename boost::proto::detail::enable_binary<
3235  field_domain,
3236  field_domain::proto_grammar,
3237  boost::mpl::and_<
3238  boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<T > >,
3239  boost::mpl::not_<
3240  boost::mpl::or_<
3241  boost::proto::is_extension<field_indirect<T,M> >,
3242  boost::proto::is_extension<T >
3243  >
3244  >
3245  >,
3246  boost::proto::tag::minus,
3247  field_indirect<T,M> const &,
3248  T const &
3249 >::type /* const */
3250 operator- (field_indirect<T,M> const &left, T const &right)
3251 {
3252  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect<T,M> const &, T const &>()(left, right);
3253 }
3254 #endif // BOOST_VERSION
3255 template<class T, class M>
3256 #if BOOST_VERSION < 104601
3257 typename
3258 boost::proto::detail::enable_binary<
3259  field_domain,
3260  is_field<field_indirect_const<T,M> >,
3261  field_indirect_const<T,M>,
3262  is_field<int >,
3263  int,
3264  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3265  ::impl<const field_indirect_const<T,M>&, const int&>::result_type const
3266 >::type
3267 operator- (const field_indirect_const<T,M>& l, const int& r)
3268 {
3269  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3270  ::impl<const field_indirect_const<T,M>&, const int&>() (l, r);
3271 }
3272 #else // BOOST_VERSION >= 104601
3273 typename boost::proto::detail::enable_binary<
3274  field_domain,
3275  field_domain::proto_grammar,
3276  boost::mpl::and_<
3277  boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<int > >,
3278  boost::mpl::not_<
3279  boost::mpl::or_<
3280  boost::proto::is_extension<field_indirect_const<T,M> >,
3281  boost::proto::is_extension<int >
3282  >
3283  >
3284  >,
3285  boost::proto::tag::minus,
3286  field_indirect_const<T,M> const &,
3287  int const &
3288 >::type /* const */
3289 operator- (field_indirect_const<T,M> const &left, int const &right)
3290 {
3291  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect_const<T,M> const &, int const &>()(left, right);
3292 }
3293 #endif // BOOST_VERSION
3294 template<class T, class M>
3295 #if BOOST_VERSION < 104601
3296 typename
3297 boost::proto::detail::enable_binary<
3298  field_domain,
3299  is_field<field_indirect_const<T,M> >,
3300  field_indirect_const<T,M>,
3301  is_field<T >,
3302  T,
3303  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3304  ::impl<const field_indirect_const<T,M>&, const T&>::result_type const
3305 >::type
3306 operator- (const field_indirect_const<T,M>& l, const T& r)
3307 {
3308  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3309  ::impl<const field_indirect_const<T,M>&, const T&>() (l, r);
3310 }
3311 #else // BOOST_VERSION >= 104601
3312 typename boost::proto::detail::enable_binary<
3313  field_domain,
3314  field_domain::proto_grammar,
3315  boost::mpl::and_<
3316  boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<T > >,
3317  boost::mpl::not_<
3318  boost::mpl::or_<
3319  boost::proto::is_extension<field_indirect_const<T,M> >,
3320  boost::proto::is_extension<T >
3321  >
3322  >
3323  >,
3324  boost::proto::tag::minus,
3325  field_indirect_const<T,M> const &,
3326  T const &
3327 >::type /* const */
3328 operator- (field_indirect_const<T,M> const &left, T const &right)
3329 {
3330  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect_const<T,M> const &, T const &>()(left, right);
3331 }
3332 #endif // BOOST_VERSION
3333 template<class T, class M>
3334 #if BOOST_VERSION < 104601
3335 typename
3336 boost::proto::detail::enable_binary<
3337  field_domain,
3338  is_field<field_component<T,M> >,
3339  field_component<T,M>,
3340  is_field<int >,
3341  int,
3342  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3343  ::impl<const field_component<T,M>&, const int&>::result_type const
3344 >::type
3345 operator- (const field_component<T,M>& l, const int& r)
3346 {
3347  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3348  ::impl<const field_component<T,M>&, const int&>() (l, r);
3349 }
3350 #else // BOOST_VERSION >= 104601
3351 typename boost::proto::detail::enable_binary<
3352  field_domain,
3353  field_domain::proto_grammar,
3354  boost::mpl::and_<
3355  boost::mpl::or_<is_field<field_component<T,M> >, is_field<int > >,
3356  boost::mpl::not_<
3357  boost::mpl::or_<
3358  boost::proto::is_extension<field_component<T,M> >,
3359  boost::proto::is_extension<int >
3360  >
3361  >
3362  >,
3363  boost::proto::tag::minus,
3364  field_component<T,M> const &,
3365  int const &
3366 >::type /* const */
3367 operator- (field_component<T,M> const &left, int const &right)
3368 {
3369  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component<T,M> const &, int const &>()(left, right);
3370 }
3371 #endif // BOOST_VERSION
3372 template<class T, class M>
3373 #if BOOST_VERSION < 104601
3374 typename
3375 boost::proto::detail::enable_binary<
3376  field_domain,
3377  is_field<field_component<T,M> >,
3378  field_component<T,M>,
3379  is_field<T >,
3380  T,
3381  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3382  ::impl<const field_component<T,M>&, const T&>::result_type const
3383 >::type
3384 operator- (const field_component<T,M>& l, const T& r)
3385 {
3386  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3387  ::impl<const field_component<T,M>&, const T&>() (l, r);
3388 }
3389 #else // BOOST_VERSION >= 104601
3390 typename boost::proto::detail::enable_binary<
3391  field_domain,
3392  field_domain::proto_grammar,
3393  boost::mpl::and_<
3394  boost::mpl::or_<is_field<field_component<T,M> >, is_field<T > >,
3395  boost::mpl::not_<
3396  boost::mpl::or_<
3397  boost::proto::is_extension<field_component<T,M> >,
3398  boost::proto::is_extension<T >
3399  >
3400  >
3401  >,
3402  boost::proto::tag::minus,
3403  field_component<T,M> const &,
3404  T const &
3405 >::type /* const */
3406 operator- (field_component<T,M> const &left, T const &right)
3407 {
3408  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component<T,M> const &, T const &>()(left, right);
3409 }
3410 #endif // BOOST_VERSION
3411 template<class T, class M>
3412 #if BOOST_VERSION < 104601
3413 typename
3414 boost::proto::detail::enable_binary<
3415  field_domain,
3416  is_field<field_component_const<T,M> >,
3417  field_component_const<T,M>,
3418  is_field<int >,
3419  int,
3420  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3421  ::impl<const field_component_const<T,M>&, const int&>::result_type const
3422 >::type
3423 operator- (const field_component_const<T,M>& l, const int& r)
3424 {
3425  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3426  ::impl<const field_component_const<T,M>&, const int&>() (l, r);
3427 }
3428 #else // BOOST_VERSION >= 104601
3429 typename boost::proto::detail::enable_binary<
3430  field_domain,
3431  field_domain::proto_grammar,
3432  boost::mpl::and_<
3433  boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<int > >,
3434  boost::mpl::not_<
3435  boost::mpl::or_<
3436  boost::proto::is_extension<field_component_const<T,M> >,
3437  boost::proto::is_extension<int >
3438  >
3439  >
3440  >,
3441  boost::proto::tag::minus,
3442  field_component_const<T,M> const &,
3443  int const &
3444 >::type /* const */
3445 operator- (field_component_const<T,M> const &left, int const &right)
3446 {
3447  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component_const<T,M> const &, int const &>()(left, right);
3448 }
3449 #endif // BOOST_VERSION
3450 template<class T, class M>
3451 #if BOOST_VERSION < 104601
3452 typename
3453 boost::proto::detail::enable_binary<
3454  field_domain,
3455  is_field<field_component_const<T,M> >,
3456  field_component_const<T,M>,
3457  is_field<T >,
3458  T,
3459  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3460  ::impl<const field_component_const<T,M>&, const T&>::result_type const
3461 >::type
3462 operator- (const field_component_const<T,M>& l, const T& r)
3463 {
3464  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3465  ::impl<const field_component_const<T,M>&, const T&>() (l, r);
3466 }
3467 #else // BOOST_VERSION >= 104601
3468 typename boost::proto::detail::enable_binary<
3469  field_domain,
3470  field_domain::proto_grammar,
3471  boost::mpl::and_<
3472  boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<T > >,
3473  boost::mpl::not_<
3474  boost::mpl::or_<
3475  boost::proto::is_extension<field_component_const<T,M> >,
3476  boost::proto::is_extension<T >
3477  >
3478  >
3479  >,
3480  boost::proto::tag::minus,
3481  field_component_const<T,M> const &,
3482  T const &
3483 >::type /* const */
3484 operator- (field_component_const<T,M> const &left, T const &right)
3485 {
3486  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component_const<T,M> const &, T const &>()(left, right);
3487 }
3488 #endif // BOOST_VERSION
3489 template<class Expr>
3490 #if BOOST_VERSION < 104601
3491 typename
3492 boost::proto::detail::enable_binary<
3493  field_domain,
3494  is_field<int >,
3495  int,
3496  is_field<field_expr<Expr> >,
3497  field_expr<Expr>,
3498  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3499  ::impl<const int&, const field_expr<Expr>&>::result_type const
3500 >::type
3501 operator- (const int& l, const field_expr<Expr>& r)
3502 {
3503  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3504  ::impl<const int&, const field_expr<Expr>&>() (l, r);
3505 }
3506 #else // BOOST_VERSION >= 104601
3507 typename boost::proto::detail::enable_binary<
3508  field_domain,
3509  field_domain::proto_grammar,
3510  boost::mpl::and_<
3511  boost::mpl::or_<is_field<int >, is_field<field_expr<Expr> > >,
3512  boost::mpl::not_<
3513  boost::mpl::or_<
3514  boost::proto::is_extension<int >,
3515  boost::proto::is_extension<field_expr<Expr> >
3516  >
3517  >
3518  >,
3519  boost::proto::tag::minus,
3520  int const &,
3521  field_expr<Expr> const &
3522 >::type /* const */
3523 operator- (int const &left, field_expr<Expr> const &right)
3524 {
3525  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, int const &, field_expr<Expr> const &>()(left, right);
3526 }
3527 #endif // BOOST_VERSION
3528 template<class Expr>
3529 #if BOOST_VERSION < 104601
3530 typename
3531 boost::proto::detail::enable_binary<
3532  field_domain,
3533  is_field<field_expr<Expr> >,
3534  field_expr<Expr>,
3535  is_field<int >,
3536  int,
3537  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3538  ::impl<const field_expr<Expr>&, const int&>::result_type const
3539 >::type
3540 operator- (const field_expr<Expr>& l, const int& r)
3541 {
3542  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3543  ::impl<const field_expr<Expr>&, const int&>() (l, r);
3544 }
3545 #else // BOOST_VERSION >= 104601
3546 typename boost::proto::detail::enable_binary<
3547  field_domain,
3548  field_domain::proto_grammar,
3549  boost::mpl::and_<
3550  boost::mpl::or_<is_field<field_expr<Expr> >, is_field<int > >,
3551  boost::mpl::not_<
3552  boost::mpl::or_<
3553  boost::proto::is_extension<field_expr<Expr> >,
3554  boost::proto::is_extension<int >
3555  >
3556  >
3557  >,
3558  boost::proto::tag::minus,
3559  field_expr<Expr> const &,
3560  int const &
3561 >::type /* const */
3562 operator- (field_expr<Expr> const &left, int const &right)
3563 {
3564  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_expr<Expr> const &, int const &>()(left, right);
3565 }
3566 #endif // BOOST_VERSION
3567 template<class T, class Expr>
3568 #if BOOST_VERSION < 104601
3569 typename
3570 boost::proto::detail::enable_binary<
3571  field_domain,
3572  is_field<T >,
3573  T,
3574  is_field<field_expr<Expr> >,
3575  field_expr<Expr>,
3576  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3577  ::impl<const T&, const field_expr<Expr>&>::result_type const
3578 >::type
3579 operator- (const T& l, const field_expr<Expr>& r)
3580 {
3581  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3582  ::impl<const T&, const field_expr<Expr>&>() (l, r);
3583 }
3584 #else // BOOST_VERSION >= 104601
3585 typename boost::proto::detail::enable_binary<
3586  field_domain,
3587  field_domain::proto_grammar,
3588  boost::mpl::and_<
3589  boost::mpl::or_<is_field<T >, is_field<field_expr<Expr> > >,
3590  boost::mpl::not_<
3591  boost::mpl::or_<
3592  boost::proto::is_extension<T >,
3593  boost::proto::is_extension<field_expr<Expr> >
3594  >
3595  >
3596  >,
3597  boost::proto::tag::minus,
3598  T const &,
3599  field_expr<Expr> const &
3600 >::type /* const */
3601 operator- (T const &left, field_expr<Expr> const &right)
3602 {
3603  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, T const &, field_expr<Expr> const &>()(left, right);
3604 }
3605 #endif // BOOST_VERSION
3606 template<class T, class Expr>
3607 #if BOOST_VERSION < 104601
3608 typename
3609 boost::proto::detail::enable_binary<
3610  field_domain,
3611  is_field<field_expr<Expr> >,
3612  field_expr<Expr>,
3613  is_field<T >,
3614  T,
3615  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3616  ::impl<const field_expr<Expr>&, const T&>::result_type const
3617 >::type
3618 operator- (const field_expr<Expr>& l, const T& r)
3619 {
3620  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3621  ::impl<const field_expr<Expr>&, const T&>() (l, r);
3622 }
3623 #else // BOOST_VERSION >= 104601
3624 typename boost::proto::detail::enable_binary<
3625  field_domain,
3626  field_domain::proto_grammar,
3627  boost::mpl::and_<
3628  boost::mpl::or_<is_field<field_expr<Expr> >, is_field<T > >,
3629  boost::mpl::not_<
3630  boost::mpl::or_<
3631  boost::proto::is_extension<field_expr<Expr> >,
3632  boost::proto::is_extension<T >
3633  >
3634  >
3635  >,
3636  boost::proto::tag::minus,
3637  field_expr<Expr> const &,
3638  T const &
3639 >::type /* const */
3640 operator- (field_expr<Expr> const &left, T const &right)
3641 {
3642  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_expr<Expr> const &, T const &>()(left, right);
3643 }
3644 #endif // BOOST_VERSION
3645 template<class T1, class T2, class M>
3646 #if BOOST_VERSION < 104601
3647 typename
3648 boost::proto::detail::enable_binary<
3649  field_domain,
3650  is_field<field_basic<T1,M> >,
3651  field_basic<T1,M>,
3652  is_field<field_basic<T2,M> >,
3653  field_basic<T2,M>,
3654  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3655  ::impl<const field_basic<T1,M>&, const field_basic<T2,M>&>::result_type const
3656 >::type
3657 operator- (const field_basic<T1,M>& l, const field_basic<T2,M>& r)
3658 {
3659  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3660  ::impl<const field_basic<T1,M>&, const field_basic<T2,M>&>() (l, r);
3661 }
3662 #else // BOOST_VERSION >= 104601
3663 typename boost::proto::detail::enable_binary<
3664  field_domain,
3665  field_domain::proto_grammar,
3666  boost::mpl::and_<
3667  boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_basic<T2,M> > >,
3668  boost::mpl::not_<
3669  boost::mpl::or_<
3670  boost::proto::is_extension<field_basic<T1,M> >,
3671  boost::proto::is_extension<field_basic<T2,M> >
3672  >
3673  >
3674  >,
3675  boost::proto::tag::minus,
3676  field_basic<T1,M> const &,
3677  field_basic<T2,M> const &
3678 >::type /* const */
3679 operator- (field_basic<T1,M> const &left, field_basic<T2,M> const &right)
3680 {
3681  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_basic<T1,M> const &, field_basic<T2,M> const &>()(left, right);
3682 }
3683 #endif // BOOST_VERSION
3684 template<class T1, class T2, class M>
3685 #if BOOST_VERSION < 104601
3686 typename
3687 boost::proto::detail::enable_binary<
3688  field_domain,
3689  is_field<field_basic<T1,M> >,
3690  field_basic<T1,M>,
3691  is_field<field_indirect<T2,M> >,
3692  field_indirect<T2,M>,
3693  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3694  ::impl<const field_basic<T1,M>&, const field_indirect<T2,M>&>::result_type const
3695 >::type
3696 operator- (const field_basic<T1,M>& l, const field_indirect<T2,M>& r)
3697 {
3698  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3699  ::impl<const field_basic<T1,M>&, const field_indirect<T2,M>&>() (l, r);
3700 }
3701 #else // BOOST_VERSION >= 104601
3702 typename boost::proto::detail::enable_binary<
3703  field_domain,
3704  field_domain::proto_grammar,
3705  boost::mpl::and_<
3706  boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_indirect<T2,M> > >,
3707  boost::mpl::not_<
3708  boost::mpl::or_<
3709  boost::proto::is_extension<field_basic<T1,M> >,
3710  boost::proto::is_extension<field_indirect<T2,M> >
3711  >
3712  >
3713  >,
3714  boost::proto::tag::minus,
3715  field_basic<T1,M> const &,
3716  field_indirect<T2,M> const &
3717 >::type /* const */
3718 operator- (field_basic<T1,M> const &left, field_indirect<T2,M> const &right)
3719 {
3720  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_basic<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
3721 }
3722 #endif // BOOST_VERSION
3723 template<class T1, class T2, class M>
3724 #if BOOST_VERSION < 104601
3725 typename
3726 boost::proto::detail::enable_binary<
3727  field_domain,
3728  is_field<field_basic<T1,M> >,
3729  field_basic<T1,M>,
3730  is_field<field_indirect_const<T2,M> >,
3731  field_indirect_const<T2,M>,
3732  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3733  ::impl<const field_basic<T1,M>&, const field_indirect_const<T2,M>&>::result_type const
3734 >::type
3735 operator- (const field_basic<T1,M>& l, const field_indirect_const<T2,M>& r)
3736 {
3737  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3738  ::impl<const field_basic<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
3739 }
3740 #else // BOOST_VERSION >= 104601
3741 typename boost::proto::detail::enable_binary<
3742  field_domain,
3743  field_domain::proto_grammar,
3744  boost::mpl::and_<
3745  boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_indirect_const<T2,M> > >,
3746  boost::mpl::not_<
3747  boost::mpl::or_<
3748  boost::proto::is_extension<field_basic<T1,M> >,
3749  boost::proto::is_extension<field_indirect_const<T2,M> >
3750  >
3751  >
3752  >,
3753  boost::proto::tag::minus,
3754  field_basic<T1,M> const &,
3755  field_indirect_const<T2,M> const &
3756 >::type /* const */
3757 operator- (field_basic<T1,M> const &left, field_indirect_const<T2,M> const &right)
3758 {
3759  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_basic<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
3760 }
3761 #endif // BOOST_VERSION
3762 template<class T1, class T2, class M>
3763 #if BOOST_VERSION < 104601
3764 typename
3765 boost::proto::detail::enable_binary<
3766  field_domain,
3767  is_field<field_basic<T1,M> >,
3768  field_basic<T1,M>,
3769  is_field<field_component<T2,M> >,
3770  field_component<T2,M>,
3771  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3772  ::impl<const field_basic<T1,M>&, const field_component<T2,M>&>::result_type const
3773 >::type
3774 operator- (const field_basic<T1,M>& l, const field_component<T2,M>& r)
3775 {
3776  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3777  ::impl<const field_basic<T1,M>&, const field_component<T2,M>&>() (l, r);
3778 }
3779 #else // BOOST_VERSION >= 104601
3780 typename boost::proto::detail::enable_binary<
3781  field_domain,
3782  field_domain::proto_grammar,
3783  boost::mpl::and_<
3784  boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_component<T2,M> > >,
3785  boost::mpl::not_<
3786  boost::mpl::or_<
3787  boost::proto::is_extension<field_basic<T1,M> >,
3788  boost::proto::is_extension<field_component<T2,M> >
3789  >
3790  >
3791  >,
3792  boost::proto::tag::minus,
3793  field_basic<T1,M> const &,
3794  field_component<T2,M> const &
3795 >::type /* const */
3796 operator- (field_basic<T1,M> const &left, field_component<T2,M> const &right)
3797 {
3798  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_basic<T1,M> const &, field_component<T2,M> const &>()(left, right);
3799 }
3800 #endif // BOOST_VERSION
3801 template<class T1, class T2, class M>
3802 #if BOOST_VERSION < 104601
3803 typename
3804 boost::proto::detail::enable_binary<
3805  field_domain,
3806  is_field<field_basic<T1,M> >,
3807  field_basic<T1,M>,
3808  is_field<field_component_const<T2,M> >,
3809  field_component_const<T2,M>,
3810  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3811  ::impl<const field_basic<T1,M>&, const field_component_const<T2,M>&>::result_type const
3812 >::type
3813 operator- (const field_basic<T1,M>& l, const field_component_const<T2,M>& r)
3814 {
3815  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3816  ::impl<const field_basic<T1,M>&, const field_component_const<T2,M>&>() (l, r);
3817 }
3818 #else // BOOST_VERSION >= 104601
3819 typename boost::proto::detail::enable_binary<
3820  field_domain,
3821  field_domain::proto_grammar,
3822  boost::mpl::and_<
3823  boost::mpl::or_<is_field<field_basic<T1,M> >, is_field<field_component_const<T2,M> > >,
3824  boost::mpl::not_<
3825  boost::mpl::or_<
3826  boost::proto::is_extension<field_basic<T1,M> >,
3827  boost::proto::is_extension<field_component_const<T2,M> >
3828  >
3829  >
3830  >,
3831  boost::proto::tag::minus,
3832  field_basic<T1,M> const &,
3833  field_component_const<T2,M> const &
3834 >::type /* const */
3835 operator- (field_basic<T1,M> const &left, field_component_const<T2,M> const &right)
3836 {
3837  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_basic<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
3838 }
3839 #endif // BOOST_VERSION
3840 template<class T1, class T2, class M>
3841 #if BOOST_VERSION < 104601
3842 typename
3843 boost::proto::detail::enable_binary<
3844  field_domain,
3845  is_field<field_indirect<T1,M> >,
3846  field_indirect<T1,M>,
3847  is_field<field_basic<T2,M> >,
3848  field_basic<T2,M>,
3849  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3850  ::impl<const field_indirect<T1,M>&, const field_basic<T2,M>&>::result_type const
3851 >::type
3852 operator- (const field_indirect<T1,M>& l, const field_basic<T2,M>& r)
3853 {
3854  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3855  ::impl<const field_indirect<T1,M>&, const field_basic<T2,M>&>() (l, r);
3856 }
3857 #else // BOOST_VERSION >= 104601
3858 typename boost::proto::detail::enable_binary<
3859  field_domain,
3860  field_domain::proto_grammar,
3861  boost::mpl::and_<
3862  boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_basic<T2,M> > >,
3863  boost::mpl::not_<
3864  boost::mpl::or_<
3865  boost::proto::is_extension<field_indirect<T1,M> >,
3866  boost::proto::is_extension<field_basic<T2,M> >
3867  >
3868  >
3869  >,
3870  boost::proto::tag::minus,
3871  field_indirect<T1,M> const &,
3872  field_basic<T2,M> const &
3873 >::type /* const */
3874 operator- (field_indirect<T1,M> const &left, field_basic<T2,M> const &right)
3875 {
3876  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect<T1,M> const &, field_basic<T2,M> const &>()(left, right);
3877 }
3878 #endif // BOOST_VERSION
3879 template<class T1, class T2, class M>
3880 #if BOOST_VERSION < 104601
3881 typename
3882 boost::proto::detail::enable_binary<
3883  field_domain,
3884  is_field<field_indirect<T1,M> >,
3885  field_indirect<T1,M>,
3886  is_field<field_indirect<T2,M> >,
3887  field_indirect<T2,M>,
3888  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3889  ::impl<const field_indirect<T1,M>&, const field_indirect<T2,M>&>::result_type const
3890 >::type
3891 operator- (const field_indirect<T1,M>& l, const field_indirect<T2,M>& r)
3892 {
3893  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3894  ::impl<const field_indirect<T1,M>&, const field_indirect<T2,M>&>() (l, r);
3895 }
3896 #else // BOOST_VERSION >= 104601
3897 typename boost::proto::detail::enable_binary<
3898  field_domain,
3899  field_domain::proto_grammar,
3900  boost::mpl::and_<
3901  boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_indirect<T2,M> > >,
3902  boost::mpl::not_<
3903  boost::mpl::or_<
3904  boost::proto::is_extension<field_indirect<T1,M> >,
3905  boost::proto::is_extension<field_indirect<T2,M> >
3906  >
3907  >
3908  >,
3909  boost::proto::tag::minus,
3910  field_indirect<T1,M> const &,
3911  field_indirect<T2,M> const &
3912 >::type /* const */
3913 operator- (field_indirect<T1,M> const &left, field_indirect<T2,M> const &right)
3914 {
3915  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
3916 }
3917 #endif // BOOST_VERSION
3918 template<class T1, class T2, class M>
3919 #if BOOST_VERSION < 104601
3920 typename
3921 boost::proto::detail::enable_binary<
3922  field_domain,
3923  is_field<field_indirect<T1,M> >,
3924  field_indirect<T1,M>,
3925  is_field<field_indirect_const<T2,M> >,
3926  field_indirect_const<T2,M>,
3927  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3928  ::impl<const field_indirect<T1,M>&, const field_indirect_const<T2,M>&>::result_type const
3929 >::type
3930 operator- (const field_indirect<T1,M>& l, const field_indirect_const<T2,M>& r)
3931 {
3932  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3933  ::impl<const field_indirect<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
3934 }
3935 #else // BOOST_VERSION >= 104601
3936 typename boost::proto::detail::enable_binary<
3937  field_domain,
3938  field_domain::proto_grammar,
3939  boost::mpl::and_<
3940  boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_indirect_const<T2,M> > >,
3941  boost::mpl::not_<
3942  boost::mpl::or_<
3943  boost::proto::is_extension<field_indirect<T1,M> >,
3944  boost::proto::is_extension<field_indirect_const<T2,M> >
3945  >
3946  >
3947  >,
3948  boost::proto::tag::minus,
3949  field_indirect<T1,M> const &,
3950  field_indirect_const<T2,M> const &
3951 >::type /* const */
3952 operator- (field_indirect<T1,M> const &left, field_indirect_const<T2,M> const &right)
3953 {
3954  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
3955 }
3956 #endif // BOOST_VERSION
3957 template<class T1, class T2, class M>
3958 #if BOOST_VERSION < 104601
3959 typename
3960 boost::proto::detail::enable_binary<
3961  field_domain,
3962  is_field<field_indirect<T1,M> >,
3963  field_indirect<T1,M>,
3964  is_field<field_component<T2,M> >,
3965  field_component<T2,M>,
3966  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3967  ::impl<const field_indirect<T1,M>&, const field_component<T2,M>&>::result_type const
3968 >::type
3969 operator- (const field_indirect<T1,M>& l, const field_component<T2,M>& r)
3970 {
3971  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
3972  ::impl<const field_indirect<T1,M>&, const field_component<T2,M>&>() (l, r);
3973 }
3974 #else // BOOST_VERSION >= 104601
3975 typename boost::proto::detail::enable_binary<
3976  field_domain,
3977  field_domain::proto_grammar,
3978  boost::mpl::and_<
3979  boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_component<T2,M> > >,
3980  boost::mpl::not_<
3981  boost::mpl::or_<
3982  boost::proto::is_extension<field_indirect<T1,M> >,
3983  boost::proto::is_extension<field_component<T2,M> >
3984  >
3985  >
3986  >,
3987  boost::proto::tag::minus,
3988  field_indirect<T1,M> const &,
3989  field_component<T2,M> const &
3990 >::type /* const */
3991 operator- (field_indirect<T1,M> const &left, field_component<T2,M> const &right)
3992 {
3993  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect<T1,M> const &, field_component<T2,M> const &>()(left, right);
3994 }
3995 #endif // BOOST_VERSION
3996 template<class T1, class T2, class M>
3997 #if BOOST_VERSION < 104601
3998 typename
3999 boost::proto::detail::enable_binary<
4000  field_domain,
4001  is_field<field_indirect<T1,M> >,
4002  field_indirect<T1,M>,
4003  is_field<field_component_const<T2,M> >,
4004  field_component_const<T2,M>,
4005  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4006  ::impl<const field_indirect<T1,M>&, const field_component_const<T2,M>&>::result_type const
4007 >::type
4008 operator- (const field_indirect<T1,M>& l, const field_component_const<T2,M>& r)
4009 {
4010  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4011  ::impl<const field_indirect<T1,M>&, const field_component_const<T2,M>&>() (l, r);
4012 }
4013 #else // BOOST_VERSION >= 104601
4014 typename boost::proto::detail::enable_binary<
4015  field_domain,
4016  field_domain::proto_grammar,
4017  boost::mpl::and_<
4018  boost::mpl::or_<is_field<field_indirect<T1,M> >, is_field<field_component_const<T2,M> > >,
4019  boost::mpl::not_<
4020  boost::mpl::or_<
4021  boost::proto::is_extension<field_indirect<T1,M> >,
4022  boost::proto::is_extension<field_component_const<T2,M> >
4023  >
4024  >
4025  >,
4026  boost::proto::tag::minus,
4027  field_indirect<T1,M> const &,
4028  field_component_const<T2,M> const &
4029 >::type /* const */
4030 operator- (field_indirect<T1,M> const &left, field_component_const<T2,M> const &right)
4031 {
4032  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
4033 }
4034 #endif // BOOST_VERSION
4035 template<class T1, class T2, class M>
4036 #if BOOST_VERSION < 104601
4037 typename
4038 boost::proto::detail::enable_binary<
4039  field_domain,
4040  is_field<field_indirect_const<T1,M> >,
4041  field_indirect_const<T1,M>,
4042  is_field<field_basic<T2,M> >,
4043  field_basic<T2,M>,
4044  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4045  ::impl<const field_indirect_const<T1,M>&, const field_basic<T2,M>&>::result_type const
4046 >::type
4047 operator- (const field_indirect_const<T1,M>& l, const field_basic<T2,M>& r)
4048 {
4049  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4050  ::impl<const field_indirect_const<T1,M>&, const field_basic<T2,M>&>() (l, r);
4051 }
4052 #else // BOOST_VERSION >= 104601
4053 typename boost::proto::detail::enable_binary<
4054  field_domain,
4055  field_domain::proto_grammar,
4056  boost::mpl::and_<
4057  boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_basic<T2,M> > >,
4058  boost::mpl::not_<
4059  boost::mpl::or_<
4060  boost::proto::is_extension<field_indirect_const<T1,M> >,
4061  boost::proto::is_extension<field_basic<T2,M> >
4062  >
4063  >
4064  >,
4065  boost::proto::tag::minus,
4066  field_indirect_const<T1,M> const &,
4067  field_basic<T2,M> const &
4068 >::type /* const */
4069 operator- (field_indirect_const<T1,M> const &left, field_basic<T2,M> const &right)
4070 {
4071  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect_const<T1,M> const &, field_basic<T2,M> const &>()(left, right);
4072 }
4073 #endif // BOOST_VERSION
4074 template<class T1, class T2, class M>
4075 #if BOOST_VERSION < 104601
4076 typename
4077 boost::proto::detail::enable_binary<
4078  field_domain,
4079  is_field<field_indirect_const<T1,M> >,
4080  field_indirect_const<T1,M>,
4081  is_field<field_indirect<T2,M> >,
4082  field_indirect<T2,M>,
4083  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4084  ::impl<const field_indirect_const<T1,M>&, const field_indirect<T2,M>&>::result_type const
4085 >::type
4086 operator- (const field_indirect_const<T1,M>& l, const field_indirect<T2,M>& r)
4087 {
4088  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4089  ::impl<const field_indirect_const<T1,M>&, const field_indirect<T2,M>&>() (l, r);
4090 }
4091 #else // BOOST_VERSION >= 104601
4092 typename boost::proto::detail::enable_binary<
4093  field_domain,
4094  field_domain::proto_grammar,
4095  boost::mpl::and_<
4096  boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_indirect<T2,M> > >,
4097  boost::mpl::not_<
4098  boost::mpl::or_<
4099  boost::proto::is_extension<field_indirect_const<T1,M> >,
4100  boost::proto::is_extension<field_indirect<T2,M> >
4101  >
4102  >
4103  >,
4104  boost::proto::tag::minus,
4105  field_indirect_const<T1,M> const &,
4106  field_indirect<T2,M> const &
4107 >::type /* const */
4108 operator- (field_indirect_const<T1,M> const &left, field_indirect<T2,M> const &right)
4109 {
4110  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect_const<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
4111 }
4112 #endif // BOOST_VERSION
4113 template<class T1, class T2, class M>
4114 #if BOOST_VERSION < 104601
4115 typename
4116 boost::proto::detail::enable_binary<
4117  field_domain,
4118  is_field<field_indirect_const<T1,M> >,
4119  field_indirect_const<T1,M>,
4120  is_field<field_indirect_const<T2,M> >,
4121  field_indirect_const<T2,M>,
4122  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4123  ::impl<const field_indirect_const<T1,M>&, const field_indirect_const<T2,M>&>::result_type const
4124 >::type
4125 operator- (const field_indirect_const<T1,M>& l, const field_indirect_const<T2,M>& r)
4126 {
4127  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4128  ::impl<const field_indirect_const<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
4129 }
4130 #else // BOOST_VERSION >= 104601
4131 typename boost::proto::detail::enable_binary<
4132  field_domain,
4133  field_domain::proto_grammar,
4134  boost::mpl::and_<
4135  boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_indirect_const<T2,M> > >,
4136  boost::mpl::not_<
4137  boost::mpl::or_<
4138  boost::proto::is_extension<field_indirect_const<T1,M> >,
4139  boost::proto::is_extension<field_indirect_const<T2,M> >
4140  >
4141  >
4142  >,
4143  boost::proto::tag::minus,
4144  field_indirect_const<T1,M> const &,
4145  field_indirect_const<T2,M> const &
4146 >::type /* const */
4147 operator- (field_indirect_const<T1,M> const &left, field_indirect_const<T2,M> const &right)
4148 {
4149  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect_const<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
4150 }
4151 #endif // BOOST_VERSION
4152 template<class T1, class T2, class M>
4153 #if BOOST_VERSION < 104601
4154 typename
4155 boost::proto::detail::enable_binary<
4156  field_domain,
4157  is_field<field_indirect_const<T1,M> >,
4158  field_indirect_const<T1,M>,
4159  is_field<field_component<T2,M> >,
4160  field_component<T2,M>,
4161  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4162  ::impl<const field_indirect_const<T1,M>&, const field_component<T2,M>&>::result_type const
4163 >::type
4164 operator- (const field_indirect_const<T1,M>& l, const field_component<T2,M>& r)
4165 {
4166  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4167  ::impl<const field_indirect_const<T1,M>&, const field_component<T2,M>&>() (l, r);
4168 }
4169 #else // BOOST_VERSION >= 104601
4170 typename boost::proto::detail::enable_binary<
4171  field_domain,
4172  field_domain::proto_grammar,
4173  boost::mpl::and_<
4174  boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_component<T2,M> > >,
4175  boost::mpl::not_<
4176  boost::mpl::or_<
4177  boost::proto::is_extension<field_indirect_const<T1,M> >,
4178  boost::proto::is_extension<field_component<T2,M> >
4179  >
4180  >
4181  >,
4182  boost::proto::tag::minus,
4183  field_indirect_const<T1,M> const &,
4184  field_component<T2,M> const &
4185 >::type /* const */
4186 operator- (field_indirect_const<T1,M> const &left, field_component<T2,M> const &right)
4187 {
4188  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect_const<T1,M> const &, field_component<T2,M> const &>()(left, right);
4189 }
4190 #endif // BOOST_VERSION
4191 template<class T1, class T2, class M>
4192 #if BOOST_VERSION < 104601
4193 typename
4194 boost::proto::detail::enable_binary<
4195  field_domain,
4196  is_field<field_indirect_const<T1,M> >,
4197  field_indirect_const<T1,M>,
4198  is_field<field_component_const<T2,M> >,
4199  field_component_const<T2,M>,
4200  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4201  ::impl<const field_indirect_const<T1,M>&, const field_component_const<T2,M>&>::result_type const
4202 >::type
4203 operator- (const field_indirect_const<T1,M>& l, const field_component_const<T2,M>& r)
4204 {
4205  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4206  ::impl<const field_indirect_const<T1,M>&, const field_component_const<T2,M>&>() (l, r);
4207 }
4208 #else // BOOST_VERSION >= 104601
4209 typename boost::proto::detail::enable_binary<
4210  field_domain,
4211  field_domain::proto_grammar,
4212  boost::mpl::and_<
4213  boost::mpl::or_<is_field<field_indirect_const<T1,M> >, is_field<field_component_const<T2,M> > >,
4214  boost::mpl::not_<
4215  boost::mpl::or_<
4216  boost::proto::is_extension<field_indirect_const<T1,M> >,
4217  boost::proto::is_extension<field_component_const<T2,M> >
4218  >
4219  >
4220  >,
4221  boost::proto::tag::minus,
4222  field_indirect_const<T1,M> const &,
4223  field_component_const<T2,M> const &
4224 >::type /* const */
4225 operator- (field_indirect_const<T1,M> const &left, field_component_const<T2,M> const &right)
4226 {
4227  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect_const<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
4228 }
4229 #endif // BOOST_VERSION
4230 template<class T1, class T2, class M>
4231 #if BOOST_VERSION < 104601
4232 typename
4233 boost::proto::detail::enable_binary<
4234  field_domain,
4235  is_field<field_component<T1,M> >,
4236  field_component<T1,M>,
4237  is_field<field_basic<T2,M> >,
4238  field_basic<T2,M>,
4239  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4240  ::impl<const field_component<T1,M>&, const field_basic<T2,M>&>::result_type const
4241 >::type
4242 operator- (const field_component<T1,M>& l, const field_basic<T2,M>& r)
4243 {
4244  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4245  ::impl<const field_component<T1,M>&, const field_basic<T2,M>&>() (l, r);
4246 }
4247 #else // BOOST_VERSION >= 104601
4248 typename boost::proto::detail::enable_binary<
4249  field_domain,
4250  field_domain::proto_grammar,
4251  boost::mpl::and_<
4252  boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_basic<T2,M> > >,
4253  boost::mpl::not_<
4254  boost::mpl::or_<
4255  boost::proto::is_extension<field_component<T1,M> >,
4256  boost::proto::is_extension<field_basic<T2,M> >
4257  >
4258  >
4259  >,
4260  boost::proto::tag::minus,
4261  field_component<T1,M> const &,
4262  field_basic<T2,M> const &
4263 >::type /* const */
4264 operator- (field_component<T1,M> const &left, field_basic<T2,M> const &right)
4265 {
4266  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component<T1,M> const &, field_basic<T2,M> const &>()(left, right);
4267 }
4268 #endif // BOOST_VERSION
4269 template<class T1, class T2, class M>
4270 #if BOOST_VERSION < 104601
4271 typename
4272 boost::proto::detail::enable_binary<
4273  field_domain,
4274  is_field<field_component<T1,M> >,
4275  field_component<T1,M>,
4276  is_field<field_indirect<T2,M> >,
4277  field_indirect<T2,M>,
4278  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4279  ::impl<const field_component<T1,M>&, const field_indirect<T2,M>&>::result_type const
4280 >::type
4281 operator- (const field_component<T1,M>& l, const field_indirect<T2,M>& r)
4282 {
4283  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4284  ::impl<const field_component<T1,M>&, const field_indirect<T2,M>&>() (l, r);
4285 }
4286 #else // BOOST_VERSION >= 104601
4287 typename boost::proto::detail::enable_binary<
4288  field_domain,
4289  field_domain::proto_grammar,
4290  boost::mpl::and_<
4291  boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_indirect<T2,M> > >,
4292  boost::mpl::not_<
4293  boost::mpl::or_<
4294  boost::proto::is_extension<field_component<T1,M> >,
4295  boost::proto::is_extension<field_indirect<T2,M> >
4296  >
4297  >
4298  >,
4299  boost::proto::tag::minus,
4300  field_component<T1,M> const &,
4301  field_indirect<T2,M> const &
4302 >::type /* const */
4303 operator- (field_component<T1,M> const &left, field_indirect<T2,M> const &right)
4304 {
4305  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
4306 }
4307 #endif // BOOST_VERSION
4308 template<class T1, class T2, class M>
4309 #if BOOST_VERSION < 104601
4310 typename
4311 boost::proto::detail::enable_binary<
4312  field_domain,
4313  is_field<field_component<T1,M> >,
4314  field_component<T1,M>,
4315  is_field<field_indirect_const<T2,M> >,
4316  field_indirect_const<T2,M>,
4317  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4318  ::impl<const field_component<T1,M>&, const field_indirect_const<T2,M>&>::result_type const
4319 >::type
4320 operator- (const field_component<T1,M>& l, const field_indirect_const<T2,M>& r)
4321 {
4322  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4323  ::impl<const field_component<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
4324 }
4325 #else // BOOST_VERSION >= 104601
4326 typename boost::proto::detail::enable_binary<
4327  field_domain,
4328  field_domain::proto_grammar,
4329  boost::mpl::and_<
4330  boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_indirect_const<T2,M> > >,
4331  boost::mpl::not_<
4332  boost::mpl::or_<
4333  boost::proto::is_extension<field_component<T1,M> >,
4334  boost::proto::is_extension<field_indirect_const<T2,M> >
4335  >
4336  >
4337  >,
4338  boost::proto::tag::minus,
4339  field_component<T1,M> const &,
4340  field_indirect_const<T2,M> const &
4341 >::type /* const */
4342 operator- (field_component<T1,M> const &left, field_indirect_const<T2,M> const &right)
4343 {
4344  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
4345 }
4346 #endif // BOOST_VERSION
4347 template<class T1, class T2, class M>
4348 #if BOOST_VERSION < 104601
4349 typename
4350 boost::proto::detail::enable_binary<
4351  field_domain,
4352  is_field<field_component<T1,M> >,
4353  field_component<T1,M>,
4354  is_field<field_component<T2,M> >,
4355  field_component<T2,M>,
4356  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4357  ::impl<const field_component<T1,M>&, const field_component<T2,M>&>::result_type const
4358 >::type
4359 operator- (const field_component<T1,M>& l, const field_component<T2,M>& r)
4360 {
4361  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4362  ::impl<const field_component<T1,M>&, const field_component<T2,M>&>() (l, r);
4363 }
4364 #else // BOOST_VERSION >= 104601
4365 typename boost::proto::detail::enable_binary<
4366  field_domain,
4367  field_domain::proto_grammar,
4368  boost::mpl::and_<
4369  boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_component<T2,M> > >,
4370  boost::mpl::not_<
4371  boost::mpl::or_<
4372  boost::proto::is_extension<field_component<T1,M> >,
4373  boost::proto::is_extension<field_component<T2,M> >
4374  >
4375  >
4376  >,
4377  boost::proto::tag::minus,
4378  field_component<T1,M> const &,
4379  field_component<T2,M> const &
4380 >::type /* const */
4381 operator- (field_component<T1,M> const &left, field_component<T2,M> const &right)
4382 {
4383  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component<T1,M> const &, field_component<T2,M> const &>()(left, right);
4384 }
4385 #endif // BOOST_VERSION
4386 template<class T1, class T2, class M>
4387 #if BOOST_VERSION < 104601
4388 typename
4389 boost::proto::detail::enable_binary<
4390  field_domain,
4391  is_field<field_component<T1,M> >,
4392  field_component<T1,M>,
4393  is_field<field_component_const<T2,M> >,
4394  field_component_const<T2,M>,
4395  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4396  ::impl<const field_component<T1,M>&, const field_component_const<T2,M>&>::result_type const
4397 >::type
4398 operator- (const field_component<T1,M>& l, const field_component_const<T2,M>& r)
4399 {
4400  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4401  ::impl<const field_component<T1,M>&, const field_component_const<T2,M>&>() (l, r);
4402 }
4403 #else // BOOST_VERSION >= 104601
4404 typename boost::proto::detail::enable_binary<
4405  field_domain,
4406  field_domain::proto_grammar,
4407  boost::mpl::and_<
4408  boost::mpl::or_<is_field<field_component<T1,M> >, is_field<field_component_const<T2,M> > >,
4409  boost::mpl::not_<
4410  boost::mpl::or_<
4411  boost::proto::is_extension<field_component<T1,M> >,
4412  boost::proto::is_extension<field_component_const<T2,M> >
4413  >
4414  >
4415  >,
4416  boost::proto::tag::minus,
4417  field_component<T1,M> const &,
4418  field_component_const<T2,M> const &
4419 >::type /* const */
4420 operator- (field_component<T1,M> const &left, field_component_const<T2,M> const &right)
4421 {
4422  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
4423 }
4424 #endif // BOOST_VERSION
4425 template<class T1, class T2, class M>
4426 #if BOOST_VERSION < 104601
4427 typename
4428 boost::proto::detail::enable_binary<
4429  field_domain,
4430  is_field<field_component_const<T1,M> >,
4431  field_component_const<T1,M>,
4432  is_field<field_basic<T2,M> >,
4433  field_basic<T2,M>,
4434  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4435  ::impl<const field_component_const<T1,M>&, const field_basic<T2,M>&>::result_type const
4436 >::type
4437 operator- (const field_component_const<T1,M>& l, const field_basic<T2,M>& r)
4438 {
4439  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4440  ::impl<const field_component_const<T1,M>&, const field_basic<T2,M>&>() (l, r);
4441 }
4442 #else // BOOST_VERSION >= 104601
4443 typename boost::proto::detail::enable_binary<
4444  field_domain,
4445  field_domain::proto_grammar,
4446  boost::mpl::and_<
4447  boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_basic<T2,M> > >,
4448  boost::mpl::not_<
4449  boost::mpl::or_<
4450  boost::proto::is_extension<field_component_const<T1,M> >,
4451  boost::proto::is_extension<field_basic<T2,M> >
4452  >
4453  >
4454  >,
4455  boost::proto::tag::minus,
4456  field_component_const<T1,M> const &,
4457  field_basic<T2,M> const &
4458 >::type /* const */
4459 operator- (field_component_const<T1,M> const &left, field_basic<T2,M> const &right)
4460 {
4461  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component_const<T1,M> const &, field_basic<T2,M> const &>()(left, right);
4462 }
4463 #endif // BOOST_VERSION
4464 template<class T1, class T2, class M>
4465 #if BOOST_VERSION < 104601
4466 typename
4467 boost::proto::detail::enable_binary<
4468  field_domain,
4469  is_field<field_component_const<T1,M> >,
4470  field_component_const<T1,M>,
4471  is_field<field_indirect<T2,M> >,
4472  field_indirect<T2,M>,
4473  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4474  ::impl<const field_component_const<T1,M>&, const field_indirect<T2,M>&>::result_type const
4475 >::type
4476 operator- (const field_component_const<T1,M>& l, const field_indirect<T2,M>& r)
4477 {
4478  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4479  ::impl<const field_component_const<T1,M>&, const field_indirect<T2,M>&>() (l, r);
4480 }
4481 #else // BOOST_VERSION >= 104601
4482 typename boost::proto::detail::enable_binary<
4483  field_domain,
4484  field_domain::proto_grammar,
4485  boost::mpl::and_<
4486  boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_indirect<T2,M> > >,
4487  boost::mpl::not_<
4488  boost::mpl::or_<
4489  boost::proto::is_extension<field_component_const<T1,M> >,
4490  boost::proto::is_extension<field_indirect<T2,M> >
4491  >
4492  >
4493  >,
4494  boost::proto::tag::minus,
4495  field_component_const<T1,M> const &,
4496  field_indirect<T2,M> const &
4497 >::type /* const */
4498 operator- (field_component_const<T1,M> const &left, field_indirect<T2,M> const &right)
4499 {
4500  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component_const<T1,M> const &, field_indirect<T2,M> const &>()(left, right);
4501 }
4502 #endif // BOOST_VERSION
4503 template<class T1, class T2, class M>
4504 #if BOOST_VERSION < 104601
4505 typename
4506 boost::proto::detail::enable_binary<
4507  field_domain,
4508  is_field<field_component_const<T1,M> >,
4509  field_component_const<T1,M>,
4510  is_field<field_indirect_const<T2,M> >,
4511  field_indirect_const<T2,M>,
4512  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4513  ::impl<const field_component_const<T1,M>&, const field_indirect_const<T2,M>&>::result_type const
4514 >::type
4515 operator- (const field_component_const<T1,M>& l, const field_indirect_const<T2,M>& r)
4516 {
4517  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4518  ::impl<const field_component_const<T1,M>&, const field_indirect_const<T2,M>&>() (l, r);
4519 }
4520 #else // BOOST_VERSION >= 104601
4521 typename boost::proto::detail::enable_binary<
4522  field_domain,
4523  field_domain::proto_grammar,
4524  boost::mpl::and_<
4525  boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_indirect_const<T2,M> > >,
4526  boost::mpl::not_<
4527  boost::mpl::or_<
4528  boost::proto::is_extension<field_component_const<T1,M> >,
4529  boost::proto::is_extension<field_indirect_const<T2,M> >
4530  >
4531  >
4532  >,
4533  boost::proto::tag::minus,
4534  field_component_const<T1,M> const &,
4535  field_indirect_const<T2,M> const &
4536 >::type /* const */
4537 operator- (field_component_const<T1,M> const &left, field_indirect_const<T2,M> const &right)
4538 {
4539  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component_const<T1,M> const &, field_indirect_const<T2,M> const &>()(left, right);
4540 }
4541 #endif // BOOST_VERSION
4542 template<class T1, class T2, class M>
4543 #if BOOST_VERSION < 104601
4544 typename
4545 boost::proto::detail::enable_binary<
4546  field_domain,
4547  is_field<field_component_const<T1,M> >,
4548  field_component_const<T1,M>,
4549  is_field<field_component<T2,M> >,
4550  field_component<T2,M>,
4551  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4552  ::impl<const field_component_const<T1,M>&, const field_component<T2,M>&>::result_type const
4553 >::type
4554 operator- (const field_component_const<T1,M>& l, const field_component<T2,M>& r)
4555 {
4556  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4557  ::impl<const field_component_const<T1,M>&, const field_component<T2,M>&>() (l, r);
4558 }
4559 #else // BOOST_VERSION >= 104601
4560 typename boost::proto::detail::enable_binary<
4561  field_domain,
4562  field_domain::proto_grammar,
4563  boost::mpl::and_<
4564  boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_component<T2,M> > >,
4565  boost::mpl::not_<
4566  boost::mpl::or_<
4567  boost::proto::is_extension<field_component_const<T1,M> >,
4568  boost::proto::is_extension<field_component<T2,M> >
4569  >
4570  >
4571  >,
4572  boost::proto::tag::minus,
4573  field_component_const<T1,M> const &,
4574  field_component<T2,M> const &
4575 >::type /* const */
4576 operator- (field_component_const<T1,M> const &left, field_component<T2,M> const &right)
4577 {
4578  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component_const<T1,M> const &, field_component<T2,M> const &>()(left, right);
4579 }
4580 #endif // BOOST_VERSION
4581 template<class T1, class T2, class M>
4582 #if BOOST_VERSION < 104601
4583 typename
4584 boost::proto::detail::enable_binary<
4585  field_domain,
4586  is_field<field_component_const<T1,M> >,
4587  field_component_const<T1,M>,
4588  is_field<field_component_const<T2,M> >,
4589  field_component_const<T2,M>,
4590  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4591  ::impl<const field_component_const<T1,M>&, const field_component_const<T2,M>&>::result_type const
4592 >::type
4593 operator- (const field_component_const<T1,M>& l, const field_component_const<T2,M>& r)
4594 {
4595  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4596  ::impl<const field_component_const<T1,M>&, const field_component_const<T2,M>&>() (l, r);
4597 }
4598 #else // BOOST_VERSION >= 104601
4599 typename boost::proto::detail::enable_binary<
4600  field_domain,
4601  field_domain::proto_grammar,
4602  boost::mpl::and_<
4603  boost::mpl::or_<is_field<field_component_const<T1,M> >, is_field<field_component_const<T2,M> > >,
4604  boost::mpl::not_<
4605  boost::mpl::or_<
4606  boost::proto::is_extension<field_component_const<T1,M> >,
4607  boost::proto::is_extension<field_component_const<T2,M> >
4608  >
4609  >
4610  >,
4611  boost::proto::tag::minus,
4612  field_component_const<T1,M> const &,
4613  field_component_const<T2,M> const &
4614 >::type /* const */
4615 operator- (field_component_const<T1,M> const &left, field_component_const<T2,M> const &right)
4616 {
4617  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component_const<T1,M> const &, field_component_const<T2,M> const &>()(left, right);
4618 }
4619 #endif // BOOST_VERSION
4620 template<class T, class M, class Expr>
4621 #if BOOST_VERSION < 104601
4622 typename
4623 boost::proto::detail::enable_binary<
4624  field_domain,
4625  is_field<field_basic<T,M> >,
4626  field_basic<T,M>,
4627  is_field<field_expr<Expr> >,
4628  field_expr<Expr>,
4629  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4630  ::impl<const field_basic<T,M>&, const field_expr<Expr>&>::result_type const
4631 >::type
4632 operator- (const field_basic<T,M>& l, const field_expr<Expr>& r)
4633 {
4634  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4635  ::impl<const field_basic<T,M>&, const field_expr<Expr>&>() (l, r);
4636 }
4637 #else // BOOST_VERSION >= 104601
4638 typename boost::proto::detail::enable_binary<
4639  field_domain,
4640  field_domain::proto_grammar,
4641  boost::mpl::and_<
4642  boost::mpl::or_<is_field<field_basic<T,M> >, is_field<field_expr<Expr> > >,
4643  boost::mpl::not_<
4644  boost::mpl::or_<
4645  boost::proto::is_extension<field_basic<T,M> >,
4646  boost::proto::is_extension<field_expr<Expr> >
4647  >
4648  >
4649  >,
4650  boost::proto::tag::minus,
4651  field_basic<T,M> const &,
4652  field_expr<Expr> const &
4653 >::type /* const */
4654 operator- (field_basic<T,M> const &left, field_expr<Expr> const &right)
4655 {
4656  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_basic<T,M> const &, field_expr<Expr> const &>()(left, right);
4657 }
4658 #endif // BOOST_VERSION
4659 template<class T, class M, class Expr>
4660 #if BOOST_VERSION < 104601
4661 typename
4662 boost::proto::detail::enable_binary<
4663  field_domain,
4664  is_field<field_expr<Expr> >,
4665  field_expr<Expr>,
4666  is_field<field_basic<T,M> >,
4667  field_basic<T,M>,
4668  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4669  ::impl<const field_expr<Expr>&, const field_basic<T,M>&>::result_type const
4670 >::type
4671 operator- (const field_expr<Expr>& l, const field_basic<T,M>& r)
4672 {
4673  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4674  ::impl<const field_expr<Expr>&, const field_basic<T,M>&>() (l, r);
4675 }
4676 #else // BOOST_VERSION >= 104601
4677 typename boost::proto::detail::enable_binary<
4678  field_domain,
4679  field_domain::proto_grammar,
4680  boost::mpl::and_<
4681  boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_basic<T,M> > >,
4682  boost::mpl::not_<
4683  boost::mpl::or_<
4684  boost::proto::is_extension<field_expr<Expr> >,
4685  boost::proto::is_extension<field_basic<T,M> >
4686  >
4687  >
4688  >,
4689  boost::proto::tag::minus,
4690  field_expr<Expr> const &,
4691  field_basic<T,M> const &
4692 >::type /* const */
4693 operator- (field_expr<Expr> const &left, field_basic<T,M> const &right)
4694 {
4695  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_expr<Expr> const &, field_basic<T,M> const &>()(left, right);
4696 }
4697 #endif // BOOST_VERSION
4698 template<class T, class M, class Expr>
4699 #if BOOST_VERSION < 104601
4700 typename
4701 boost::proto::detail::enable_binary<
4702  field_domain,
4703  is_field<field_indirect<T,M> >,
4704  field_indirect<T,M>,
4705  is_field<field_expr<Expr> >,
4706  field_expr<Expr>,
4707  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4708  ::impl<const field_indirect<T,M>&, const field_expr<Expr>&>::result_type const
4709 >::type
4710 operator- (const field_indirect<T,M>& l, const field_expr<Expr>& r)
4711 {
4712  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4713  ::impl<const field_indirect<T,M>&, const field_expr<Expr>&>() (l, r);
4714 }
4715 #else // BOOST_VERSION >= 104601
4716 typename boost::proto::detail::enable_binary<
4717  field_domain,
4718  field_domain::proto_grammar,
4719  boost::mpl::and_<
4720  boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<field_expr<Expr> > >,
4721  boost::mpl::not_<
4722  boost::mpl::or_<
4723  boost::proto::is_extension<field_indirect<T,M> >,
4724  boost::proto::is_extension<field_expr<Expr> >
4725  >
4726  >
4727  >,
4728  boost::proto::tag::minus,
4729  field_indirect<T,M> const &,
4730  field_expr<Expr> const &
4731 >::type /* const */
4732 operator- (field_indirect<T,M> const &left, field_expr<Expr> const &right)
4733 {
4734  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect<T,M> const &, field_expr<Expr> const &>()(left, right);
4735 }
4736 #endif // BOOST_VERSION
4737 template<class T, class M, class Expr>
4738 #if BOOST_VERSION < 104601
4739 typename
4740 boost::proto::detail::enable_binary<
4741  field_domain,
4742  is_field<field_expr<Expr> >,
4743  field_expr<Expr>,
4744  is_field<field_indirect<T,M> >,
4745  field_indirect<T,M>,
4746  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4747  ::impl<const field_expr<Expr>&, const field_indirect<T,M>&>::result_type const
4748 >::type
4749 operator- (const field_expr<Expr>& l, const field_indirect<T,M>& r)
4750 {
4751  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4752  ::impl<const field_expr<Expr>&, const field_indirect<T,M>&>() (l, r);
4753 }
4754 #else // BOOST_VERSION >= 104601
4755 typename boost::proto::detail::enable_binary<
4756  field_domain,
4757  field_domain::proto_grammar,
4758  boost::mpl::and_<
4759  boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_indirect<T,M> > >,
4760  boost::mpl::not_<
4761  boost::mpl::or_<
4762  boost::proto::is_extension<field_expr<Expr> >,
4763  boost::proto::is_extension<field_indirect<T,M> >
4764  >
4765  >
4766  >,
4767  boost::proto::tag::minus,
4768  field_expr<Expr> const &,
4769  field_indirect<T,M> const &
4770 >::type /* const */
4771 operator- (field_expr<Expr> const &left, field_indirect<T,M> const &right)
4772 {
4773  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_expr<Expr> const &, field_indirect<T,M> const &>()(left, right);
4774 }
4775 #endif // BOOST_VERSION
4776 template<class T, class M, class Expr>
4777 #if BOOST_VERSION < 104601
4778 typename
4779 boost::proto::detail::enable_binary<
4780  field_domain,
4781  is_field<field_indirect_const<T,M> >,
4782  field_indirect_const<T,M>,
4783  is_field<field_expr<Expr> >,
4784  field_expr<Expr>,
4785  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4786  ::impl<const field_indirect_const<T,M>&, const field_expr<Expr>&>::result_type const
4787 >::type
4788 operator- (const field_indirect_const<T,M>& l, const field_expr<Expr>& r)
4789 {
4790  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4791  ::impl<const field_indirect_const<T,M>&, const field_expr<Expr>&>() (l, r);
4792 }
4793 #else // BOOST_VERSION >= 104601
4794 typename boost::proto::detail::enable_binary<
4795  field_domain,
4796  field_domain::proto_grammar,
4797  boost::mpl::and_<
4798  boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<field_expr<Expr> > >,
4799  boost::mpl::not_<
4800  boost::mpl::or_<
4801  boost::proto::is_extension<field_indirect_const<T,M> >,
4802  boost::proto::is_extension<field_expr<Expr> >
4803  >
4804  >
4805  >,
4806  boost::proto::tag::minus,
4807  field_indirect_const<T,M> const &,
4808  field_expr<Expr> const &
4809 >::type /* const */
4810 operator- (field_indirect_const<T,M> const &left, field_expr<Expr> const &right)
4811 {
4812  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_indirect_const<T,M> const &, field_expr<Expr> const &>()(left, right);
4813 }
4814 #endif // BOOST_VERSION
4815 template<class T, class M, class Expr>
4816 #if BOOST_VERSION < 104601
4817 typename
4818 boost::proto::detail::enable_binary<
4819  field_domain,
4820  is_field<field_expr<Expr> >,
4821  field_expr<Expr>,
4822  is_field<field_indirect_const<T,M> >,
4823  field_indirect_const<T,M>,
4824  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4825  ::impl<const field_expr<Expr>&, const field_indirect_const<T,M>&>::result_type const
4826 >::type
4827 operator- (const field_expr<Expr>& l, const field_indirect_const<T,M>& r)
4828 {
4829  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4830  ::impl<const field_expr<Expr>&, const field_indirect_const<T,M>&>() (l, r);
4831 }
4832 #else // BOOST_VERSION >= 104601
4833 typename boost::proto::detail::enable_binary<
4834  field_domain,
4835  field_domain::proto_grammar,
4836  boost::mpl::and_<
4837  boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_indirect_const<T,M> > >,
4838  boost::mpl::not_<
4839  boost::mpl::or_<
4840  boost::proto::is_extension<field_expr<Expr> >,
4841  boost::proto::is_extension<field_indirect_const<T,M> >
4842  >
4843  >
4844  >,
4845  boost::proto::tag::minus,
4846  field_expr<Expr> const &,
4847  field_indirect_const<T,M> const &
4848 >::type /* const */
4849 operator- (field_expr<Expr> const &left, field_indirect_const<T,M> const &right)
4850 {
4851  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_expr<Expr> const &, field_indirect_const<T,M> const &>()(left, right);
4852 }
4853 #endif // BOOST_VERSION
4854 template<class T, class M, class Expr>
4855 #if BOOST_VERSION < 104601
4856 typename
4857 boost::proto::detail::enable_binary<
4858  field_domain,
4859  is_field<field_component<T,M> >,
4860  field_component<T,M>,
4861  is_field<field_expr<Expr> >,
4862  field_expr<Expr>,
4863  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4864  ::impl<const field_component<T,M>&, const field_expr<Expr>&>::result_type const
4865 >::type
4866 operator- (const field_component<T,M>& l, const field_expr<Expr>& r)
4867 {
4868  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4869  ::impl<const field_component<T,M>&, const field_expr<Expr>&>() (l, r);
4870 }
4871 #else // BOOST_VERSION >= 104601
4872 typename boost::proto::detail::enable_binary<
4873  field_domain,
4874  field_domain::proto_grammar,
4875  boost::mpl::and_<
4876  boost::mpl::or_<is_field<field_component<T,M> >, is_field<field_expr<Expr> > >,
4877  boost::mpl::not_<
4878  boost::mpl::or_<
4879  boost::proto::is_extension<field_component<T,M> >,
4880  boost::proto::is_extension<field_expr<Expr> >
4881  >
4882  >
4883  >,
4884  boost::proto::tag::minus,
4885  field_component<T,M> const &,
4886  field_expr<Expr> const &
4887 >::type /* const */
4888 operator- (field_component<T,M> const &left, field_expr<Expr> const &right)
4889 {
4890  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component<T,M> const &, field_expr<Expr> const &>()(left, right);
4891 }
4892 #endif // BOOST_VERSION
4893 template<class T, class M, class Expr>
4894 #if BOOST_VERSION < 104601
4895 typename
4896 boost::proto::detail::enable_binary<
4897  field_domain,
4898  is_field<field_expr<Expr> >,
4899  field_expr<Expr>,
4900  is_field<field_component<T,M> >,
4901  field_component<T,M>,
4902  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4903  ::impl<const field_expr<Expr>&, const field_component<T,M>&>::result_type const
4904 >::type
4905 operator- (const field_expr<Expr>& l, const field_component<T,M>& r)
4906 {
4907  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4908  ::impl<const field_expr<Expr>&, const field_component<T,M>&>() (l, r);
4909 }
4910 #else // BOOST_VERSION >= 104601
4911 typename boost::proto::detail::enable_binary<
4912  field_domain,
4913  field_domain::proto_grammar,
4914  boost::mpl::and_<
4915  boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_component<T,M> > >,
4916  boost::mpl::not_<
4917  boost::mpl::or_<
4918  boost::proto::is_extension<field_expr<Expr> >,
4919  boost::proto::is_extension<field_component<T,M> >
4920  >
4921  >
4922  >,
4923  boost::proto::tag::minus,
4924  field_expr<Expr> const &,
4925  field_component<T,M> const &
4926 >::type /* const */
4927 operator- (field_expr<Expr> const &left, field_component<T,M> const &right)
4928 {
4929  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_expr<Expr> const &, field_component<T,M> const &>()(left, right);
4930 }
4931 #endif // BOOST_VERSION
4932 template<class T, class M, class Expr>
4933 #if BOOST_VERSION < 104601
4934 typename
4935 boost::proto::detail::enable_binary<
4936  field_domain,
4937  is_field<field_component_const<T,M> >,
4938  field_component_const<T,M>,
4939  is_field<field_expr<Expr> >,
4940  field_expr<Expr>,
4941  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4942  ::impl<const field_component_const<T,M>&, const field_expr<Expr>&>::result_type const
4943 >::type
4944 operator- (const field_component_const<T,M>& l, const field_expr<Expr>& r)
4945 {
4946  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4947  ::impl<const field_component_const<T,M>&, const field_expr<Expr>&>() (l, r);
4948 }
4949 #else // BOOST_VERSION >= 104601
4950 typename boost::proto::detail::enable_binary<
4951  field_domain,
4952  field_domain::proto_grammar,
4953  boost::mpl::and_<
4954  boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<field_expr<Expr> > >,
4955  boost::mpl::not_<
4956  boost::mpl::or_<
4957  boost::proto::is_extension<field_component_const<T,M> >,
4958  boost::proto::is_extension<field_expr<Expr> >
4959  >
4960  >
4961  >,
4962  boost::proto::tag::minus,
4963  field_component_const<T,M> const &,
4964  field_expr<Expr> const &
4965 >::type /* const */
4966 operator- (field_component_const<T,M> const &left, field_expr<Expr> const &right)
4967 {
4968  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_component_const<T,M> const &, field_expr<Expr> const &>()(left, right);
4969 }
4970 #endif // BOOST_VERSION
4971 template<class T, class M, class Expr>
4972 #if BOOST_VERSION < 104601
4973 typename
4974 boost::proto::detail::enable_binary<
4975  field_domain,
4976  is_field<field_expr<Expr> >,
4977  field_expr<Expr>,
4978  is_field<field_component_const<T,M> >,
4979  field_component_const<T,M>,
4980  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4981  ::impl<const field_expr<Expr>&, const field_component_const<T,M>&>::result_type const
4982 >::type
4983 operator- (const field_expr<Expr>& l, const field_component_const<T,M>& r)
4984 {
4985  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
4986  ::impl<const field_expr<Expr>&, const field_component_const<T,M>&>() (l, r);
4987 }
4988 #else // BOOST_VERSION >= 104601
4989 typename boost::proto::detail::enable_binary<
4990  field_domain,
4991  field_domain::proto_grammar,
4992  boost::mpl::and_<
4993  boost::mpl::or_<is_field<field_expr<Expr> >, is_field<field_component_const<T,M> > >,
4994  boost::mpl::not_<
4995  boost::mpl::or_<
4996  boost::proto::is_extension<field_expr<Expr> >,
4997  boost::proto::is_extension<field_component_const<T,M> >
4998  >
4999  >
5000  >,
5001  boost::proto::tag::minus,
5002  field_expr<Expr> const &,
5003  field_component_const<T,M> const &
5004 >::type /* const */
5005 operator- (field_expr<Expr> const &left, field_component_const<T,M> const &right)
5006 {
5007  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_expr<Expr> const &, field_component_const<T,M> const &>()(left, right);
5008 }
5009 #endif // BOOST_VERSION
5010 template<class Expr1, class Expr2>
5011 #if BOOST_VERSION < 104601
5012 typename
5013 boost::proto::detail::enable_binary<
5014  field_domain,
5015  is_field<field_expr<Expr1> >,
5016  field_expr<Expr1>,
5017  is_field<field_expr<Expr2> >,
5018  field_expr<Expr2>,
5019  typename boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
5020  ::impl<const field_expr<Expr1>&, const field_expr<Expr2>&>::result_type const
5021 >::type
5022 operator- (const field_expr<Expr1>& l, const field_expr<Expr2>& r)
5023 {
5024  return boost::proto::functional::make_expr<boost::proto::tag::minus, field_domain>
5025  ::impl<const field_expr<Expr1>&, const field_expr<Expr2>&>() (l, r);
5026 }
5027 #else // BOOST_VERSION >= 104601
5028 typename boost::proto::detail::enable_binary<
5029  field_domain,
5030  field_domain::proto_grammar,
5031  boost::mpl::and_<
5032  boost::mpl::or_<is_field<field_expr<Expr1> >, is_field<field_expr<Expr2> > >,
5033  boost::mpl::not_<
5034  boost::mpl::or_<
5035  boost::proto::is_extension<field_expr<Expr1> >,
5036  boost::proto::is_extension<field_expr<Expr2> >
5037  >
5038  >
5039  >,
5040  boost::proto::tag::minus,
5041  field_expr<Expr1> const &,
5042  field_expr<Expr2> const &
5043 >::type /* const */
5044 operator- (field_expr<Expr1> const &left, field_expr<Expr2> const &right)
5045 {
5046  return boost::proto::detail::make_expr_<boost::proto::tag::minus, field_domain, field_expr<Expr1> const &, field_expr<Expr2> const &>()(left, right);
5047 }
5048 #endif // BOOST_VERSION
5049 template<class T, class M>
5050 #if BOOST_VERSION < 104601
5051 typename
5052 boost::proto::detail::enable_binary<
5053  field_domain,
5054  is_field<int >,
5055  int,
5056  is_field<field_basic<T,M> >,
5057  field_basic<T,M>,
5058  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5059  ::impl<const int&, const field_basic<T,M>&>::result_type const
5060 >::type
5061 operator* (const int& l, const field_basic<T,M>& r)
5062 {
5063  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5064  ::impl<const int&, const field_basic<T,M>&>() (l, r);
5065 }
5066 #else // BOOST_VERSION >= 104601
5067 typename boost::proto::detail::enable_binary<
5068  field_domain,
5069  field_domain::proto_grammar,
5070  boost::mpl::and_<
5071  boost::mpl::or_<is_field<int >, is_field<field_basic<T,M> > >,
5072  boost::mpl::not_<
5073  boost::mpl::or_<
5074  boost::proto::is_extension<int >,
5075  boost::proto::is_extension<field_basic<T,M> >
5076  >
5077  >
5078  >,
5079  boost::proto::tag::multiplies,
5080  int const &,
5081  field_basic<T,M> const &
5082 >::type /* const */
5083 operator* (int const &left, field_basic<T,M> const &right)
5084 {
5085  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, int const &, field_basic<T,M> const &>()(left, right);
5086 }
5087 #endif // BOOST_VERSION
5088 template<class T, class M>
5089 #if BOOST_VERSION < 104601
5090 typename
5091 boost::proto::detail::enable_binary<
5092  field_domain,
5093  is_field<T >,
5094  T,
5095  is_field<field_basic<T,M> >,
5096  field_basic<T,M>,
5097  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5098  ::impl<const T&, const field_basic<T,M>&>::result_type const
5099 >::type
5100 operator* (const T& l, const field_basic<T,M>& r)
5101 {
5102  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5103  ::impl<const T&, const field_basic<T,M>&>() (l, r);
5104 }
5105 #else // BOOST_VERSION >= 104601
5106 typename boost::proto::detail::enable_binary<
5107  field_domain,
5108  field_domain::proto_grammar,
5109  boost::mpl::and_<
5110  boost::mpl::or_<is_field<T >, is_field<field_basic<T,M> > >,
5111  boost::mpl::not_<
5112  boost::mpl::or_<
5113  boost::proto::is_extension<T >,
5114  boost::proto::is_extension<field_basic<T,M> >
5115  >
5116  >
5117  >,
5118  boost::proto::tag::multiplies,
5119  T const &,
5120  field_basic<T,M> const &
5121 >::type /* const */
5122 operator* (T const &left, field_basic<T,M> const &right)
5123 {
5124  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, T const &, field_basic<T,M> const &>()(left, right);
5125 }
5126 #endif // BOOST_VERSION
5127 template<class T, class M>
5128 #if BOOST_VERSION < 104601
5129 typename
5130 boost::proto::detail::enable_binary<
5131  field_domain,
5132  is_field<int >,
5133  int,
5134  is_field<field_indirect<T,M> >,
5135  field_indirect<T,M>,
5136  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5137  ::impl<const int&, const field_indirect<T,M>&>::result_type const
5138 >::type
5139 operator* (const int& l, const field_indirect<T,M>& r)
5140 {
5141  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5142  ::impl<const int&, const field_indirect<T,M>&>() (l, r);
5143 }
5144 #else // BOOST_VERSION >= 104601
5145 typename boost::proto::detail::enable_binary<
5146  field_domain,
5147  field_domain::proto_grammar,
5148  boost::mpl::and_<
5149  boost::mpl::or_<is_field<int >, is_field<field_indirect<T,M> > >,
5150  boost::mpl::not_<
5151  boost::mpl::or_<
5152  boost::proto::is_extension<int >,
5153  boost::proto::is_extension<field_indirect<T,M> >
5154  >
5155  >
5156  >,
5157  boost::proto::tag::multiplies,
5158  int const &,
5159  field_indirect<T,M> const &
5160 >::type /* const */
5161 operator* (int const &left, field_indirect<T,M> const &right)
5162 {
5163  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, int const &, field_indirect<T,M> const &>()(left, right);
5164 }
5165 #endif // BOOST_VERSION
5166 template<class T, class M>
5167 #if BOOST_VERSION < 104601
5168 typename
5169 boost::proto::detail::enable_binary<
5170  field_domain,
5171  is_field<T >,
5172  T,
5173  is_field<field_indirect<T,M> >,
5174  field_indirect<T,M>,
5175  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5176  ::impl<const T&, const field_indirect<T,M>&>::result_type const
5177 >::type
5178 operator* (const T& l, const field_indirect<T,M>& r)
5179 {
5180  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5181  ::impl<const T&, const field_indirect<T,M>&>() (l, r);
5182 }
5183 #else // BOOST_VERSION >= 104601
5184 typename boost::proto::detail::enable_binary<
5185  field_domain,
5186  field_domain::proto_grammar,
5187  boost::mpl::and_<
5188  boost::mpl::or_<is_field<T >, is_field<field_indirect<T,M> > >,
5189  boost::mpl::not_<
5190  boost::mpl::or_<
5191  boost::proto::is_extension<T >,
5192  boost::proto::is_extension<field_indirect<T,M> >
5193  >
5194  >
5195  >,
5196  boost::proto::tag::multiplies,
5197  T const &,
5198  field_indirect<T,M> const &
5199 >::type /* const */
5200 operator* (T const &left, field_indirect<T,M> const &right)
5201 {
5202  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, T const &, field_indirect<T,M> const &>()(left, right);
5203 }
5204 #endif // BOOST_VERSION
5205 template<class T, class M>
5206 #if BOOST_VERSION < 104601
5207 typename
5208 boost::proto::detail::enable_binary<
5209  field_domain,
5210  is_field<int >,
5211  int,
5212  is_field<field_indirect_const<T,M> >,
5213  field_indirect_const<T,M>,
5214  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5215  ::impl<const int&, const field_indirect_const<T,M>&>::result_type const
5216 >::type
5217 operator* (const int& l, const field_indirect_const<T,M>& r)
5218 {
5219  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5220  ::impl<const int&, const field_indirect_const<T,M>&>() (l, r);
5221 }
5222 #else // BOOST_VERSION >= 104601
5223 typename boost::proto::detail::enable_binary<
5224  field_domain,
5225  field_domain::proto_grammar,
5226  boost::mpl::and_<
5227  boost::mpl::or_<is_field<int >, is_field<field_indirect_const<T,M> > >,
5228  boost::mpl::not_<
5229  boost::mpl::or_<
5230  boost::proto::is_extension<int >,
5231  boost::proto::is_extension<field_indirect_const<T,M> >
5232  >
5233  >
5234  >,
5235  boost::proto::tag::multiplies,
5236  int const &,
5237  field_indirect_const<T,M> const &
5238 >::type /* const */
5239 operator* (int const &left, field_indirect_const<T,M> const &right)
5240 {
5241  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, int const &, field_indirect_const<T,M> const &>()(left, right);
5242 }
5243 #endif // BOOST_VERSION
5244 template<class T, class M>
5245 #if BOOST_VERSION < 104601
5246 typename
5247 boost::proto::detail::enable_binary<
5248  field_domain,
5249  is_field<T >,
5250  T,
5251  is_field<field_indirect_const<T,M> >,
5252  field_indirect_const<T,M>,
5253  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5254  ::impl<const T&, const field_indirect_const<T,M>&>::result_type const
5255 >::type
5256 operator* (const T& l, const field_indirect_const<T,M>& r)
5257 {
5258  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5259  ::impl<const T&, const field_indirect_const<T,M>&>() (l, r);
5260 }
5261 #else // BOOST_VERSION >= 104601
5262 typename boost::proto::detail::enable_binary<
5263  field_domain,
5264  field_domain::proto_grammar,
5265  boost::mpl::and_<
5266  boost::mpl::or_<is_field<T >, is_field<field_indirect_const<T,M> > >,
5267  boost::mpl::not_<
5268  boost::mpl::or_<
5269  boost::proto::is_extension<T >,
5270  boost::proto::is_extension<field_indirect_const<T,M> >
5271  >
5272  >
5273  >,
5274  boost::proto::tag::multiplies,
5275  T const &,
5276  field_indirect_const<T,M> const &
5277 >::type /* const */
5278 operator* (T const &left, field_indirect_const<T,M> const &right)
5279 {
5280  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, T const &, field_indirect_const<T,M> const &>()(left, right);
5281 }
5282 #endif // BOOST_VERSION
5283 template<class T, class M>
5284 #if BOOST_VERSION < 104601
5285 typename
5286 boost::proto::detail::enable_binary<
5287  field_domain,
5288  is_field<int >,
5289  int,
5290  is_field<field_component<T,M> >,
5291  field_component<T,M>,
5292  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5293  ::impl<const int&, const field_component<T,M>&>::result_type const
5294 >::type
5295 operator* (const int& l, const field_component<T,M>& r)
5296 {
5297  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5298  ::impl<const int&, const field_component<T,M>&>() (l, r);
5299 }
5300 #else // BOOST_VERSION >= 104601
5301 typename boost::proto::detail::enable_binary<
5302  field_domain,
5303  field_domain::proto_grammar,
5304  boost::mpl::and_<
5305  boost::mpl::or_<is_field<int >, is_field<field_component<T,M> > >,
5306  boost::mpl::not_<
5307  boost::mpl::or_<
5308  boost::proto::is_extension<int >,
5309  boost::proto::is_extension<field_component<T,M> >
5310  >
5311  >
5312  >,
5313  boost::proto::tag::multiplies,
5314  int const &,
5315  field_component<T,M> const &
5316 >::type /* const */
5317 operator* (int const &left, field_component<T,M> const &right)
5318 {
5319  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, int const &, field_component<T,M> const &>()(left, right);
5320 }
5321 #endif // BOOST_VERSION
5322 template<class T, class M>
5323 #if BOOST_VERSION < 104601
5324 typename
5325 boost::proto::detail::enable_binary<
5326  field_domain,
5327  is_field<T >,
5328  T,
5329  is_field<field_component<T,M> >,
5330  field_component<T,M>,
5331  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5332  ::impl<const T&, const field_component<T,M>&>::result_type const
5333 >::type
5334 operator* (const T& l, const field_component<T,M>& r)
5335 {
5336  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5337  ::impl<const T&, const field_component<T,M>&>() (l, r);
5338 }
5339 #else // BOOST_VERSION >= 104601
5340 typename boost::proto::detail::enable_binary<
5341  field_domain,
5342  field_domain::proto_grammar,
5343  boost::mpl::and_<
5344  boost::mpl::or_<is_field<T >, is_field<field_component<T,M> > >,
5345  boost::mpl::not_<
5346  boost::mpl::or_<
5347  boost::proto::is_extension<T >,
5348  boost::proto::is_extension<field_component<T,M> >
5349  >
5350  >
5351  >,
5352  boost::proto::tag::multiplies,
5353  T const &,
5354  field_component<T,M> const &
5355 >::type /* const */
5356 operator* (T const &left, field_component<T,M> const &right)
5357 {
5358  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, T const &, field_component<T,M> const &>()(left, right);
5359 }
5360 #endif // BOOST_VERSION
5361 template<class T, class M>
5362 #if BOOST_VERSION < 104601
5363 typename
5364 boost::proto::detail::enable_binary<
5365  field_domain,
5366  is_field<int >,
5367  int,
5368  is_field<field_component_const<T,M> >,
5369  field_component_const<T,M>,
5370  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5371  ::impl<const int&, const field_component_const<T,M>&>::result_type const
5372 >::type
5373 operator* (const int& l, const field_component_const<T,M>& r)
5374 {
5375  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5376  ::impl<const int&, const field_component_const<T,M>&>() (l, r);
5377 }
5378 #else // BOOST_VERSION >= 104601
5379 typename boost::proto::detail::enable_binary<
5380  field_domain,
5381  field_domain::proto_grammar,
5382  boost::mpl::and_<
5383  boost::mpl::or_<is_field<int >, is_field<field_component_const<T,M> > >,
5384  boost::mpl::not_<
5385  boost::mpl::or_<
5386  boost::proto::is_extension<int >,
5387  boost::proto::is_extension<field_component_const<T,M> >
5388  >
5389  >
5390  >,
5391  boost::proto::tag::multiplies,
5392  int const &,
5393  field_component_const<T,M> const &
5394 >::type /* const */
5395 operator* (int const &left, field_component_const<T,M> const &right)
5396 {
5397  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, int const &, field_component_const<T,M> const &>()(left, right);
5398 }
5399 #endif // BOOST_VERSION
5400 template<class T, class M>
5401 #if BOOST_VERSION < 104601
5402 typename
5403 boost::proto::detail::enable_binary<
5404  field_domain,
5405  is_field<T >,
5406  T,
5407  is_field<field_component_const<T,M> >,
5408  field_component_const<T,M>,
5409  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5410  ::impl<const T&, const field_component_const<T,M>&>::result_type const
5411 >::type
5412 operator* (const T& l, const field_component_const<T,M>& r)
5413 {
5414  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5415  ::impl<const T&, const field_component_const<T,M>&>() (l, r);
5416 }
5417 #else // BOOST_VERSION >= 104601
5418 typename boost::proto::detail::enable_binary<
5419  field_domain,
5420  field_domain::proto_grammar,
5421  boost::mpl::and_<
5422  boost::mpl::or_<is_field<T >, is_field<field_component_const<T,M> > >,
5423  boost::mpl::not_<
5424  boost::mpl::or_<
5425  boost::proto::is_extension<T >,
5426  boost::proto::is_extension<field_component_const<T,M> >
5427  >
5428  >
5429  >,
5430  boost::proto::tag::multiplies,
5431  T const &,
5432  field_component_const<T,M> const &
5433 >::type /* const */
5434 operator* (T const &left, field_component_const<T,M> const &right)
5435 {
5436  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, T const &, field_component_const<T,M> const &>()(left, right);
5437 }
5438 #endif // BOOST_VERSION
5439 template<class T, class M>
5440 #if BOOST_VERSION < 104601
5441 typename
5442 boost::proto::detail::enable_binary<
5443  field_domain,
5444  is_field<field_basic<T,M> >,
5445  field_basic<T,M>,
5446  is_field<int >,
5447  int,
5448  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5449  ::impl<const field_basic<T,M>&, const int&>::result_type const
5450 >::type
5451 operator* (const field_basic<T,M>& l, const int& r)
5452 {
5453  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5454  ::impl<const field_basic<T,M>&, const int&>() (l, r);
5455 }
5456 #else // BOOST_VERSION >= 104601
5457 typename boost::proto::detail::enable_binary<
5458  field_domain,
5459  field_domain::proto_grammar,
5460  boost::mpl::and_<
5461  boost::mpl::or_<is_field<field_basic<T,M> >, is_field<int > >,
5462  boost::mpl::not_<
5463  boost::mpl::or_<
5464  boost::proto::is_extension<field_basic<T,M> >,
5465  boost::proto::is_extension<int >
5466  >
5467  >
5468  >,
5469  boost::proto::tag::multiplies,
5470  field_basic<T,M> const &,
5471  int const &
5472 >::type /* const */
5473 operator* (field_basic<T,M> const &left, int const &right)
5474 {
5475  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_basic<T,M> const &, int const &>()(left, right);
5476 }
5477 #endif // BOOST_VERSION
5478 template<class T, class M>
5479 #if BOOST_VERSION < 104601
5480 typename
5481 boost::proto::detail::enable_binary<
5482  field_domain,
5483  is_field<field_basic<T,M> >,
5484  field_basic<T,M>,
5485  is_field<T >,
5486  T,
5487  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5488  ::impl<const field_basic<T,M>&, const T&>::result_type const
5489 >::type
5490 operator* (const field_basic<T,M>& l, const T& r)
5491 {
5492  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5493  ::impl<const field_basic<T,M>&, const T&>() (l, r);
5494 }
5495 #else // BOOST_VERSION >= 104601
5496 typename boost::proto::detail::enable_binary<
5497  field_domain,
5498  field_domain::proto_grammar,
5499  boost::mpl::and_<
5500  boost::mpl::or_<is_field<field_basic<T,M> >, is_field<T > >,
5501  boost::mpl::not_<
5502  boost::mpl::or_<
5503  boost::proto::is_extension<field_basic<T,M> >,
5504  boost::proto::is_extension<T >
5505  >
5506  >
5507  >,
5508  boost::proto::tag::multiplies,
5509  field_basic<T,M> const &,
5510  T const &
5511 >::type /* const */
5512 operator* (field_basic<T,M> const &left, T const &right)
5513 {
5514  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_basic<T,M> const &, T const &>()(left, right);
5515 }
5516 #endif // BOOST_VERSION
5517 template<class T, class M>
5518 #if BOOST_VERSION < 104601
5519 typename
5520 boost::proto::detail::enable_binary<
5521  field_domain,
5522  is_field<field_indirect<T,M> >,
5523  field_indirect<T,M>,
5524  is_field<int >,
5525  int,
5526  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5527  ::impl<const field_indirect<T,M>&, const int&>::result_type const
5528 >::type
5529 operator* (const field_indirect<T,M>& l, const int& r)
5530 {
5531  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5532  ::impl<const field_indirect<T,M>&, const int&>() (l, r);
5533 }
5534 #else // BOOST_VERSION >= 104601
5535 typename boost::proto::detail::enable_binary<
5536  field_domain,
5537  field_domain::proto_grammar,
5538  boost::mpl::and_<
5539  boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<int > >,
5540  boost::mpl::not_<
5541  boost::mpl::or_<
5542  boost::proto::is_extension<field_indirect<T,M> >,
5543  boost::proto::is_extension<int >
5544  >
5545  >
5546  >,
5547  boost::proto::tag::multiplies,
5548  field_indirect<T,M> const &,
5549  int const &
5550 >::type /* const */
5551 operator* (field_indirect<T,M> const &left, int const &right)
5552 {
5553  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect<T,M> const &, int const &>()(left, right);
5554 }
5555 #endif // BOOST_VERSION
5556 template<class T, class M>
5557 #if BOOST_VERSION < 104601
5558 typename
5559 boost::proto::detail::enable_binary<
5560  field_domain,
5561  is_field<field_indirect<T,M> >,
5562  field_indirect<T,M>,
5563  is_field<T >,
5564  T,
5565  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5566  ::impl<const field_indirect<T,M>&, const T&>::result_type const
5567 >::type
5568 operator* (const field_indirect<T,M>& l, const T& r)
5569 {
5570  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5571  ::impl<const field_indirect<T,M>&, const T&>() (l, r);
5572 }
5573 #else // BOOST_VERSION >= 104601
5574 typename boost::proto::detail::enable_binary<
5575  field_domain,
5576  field_domain::proto_grammar,
5577  boost::mpl::and_<
5578  boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<T > >,
5579  boost::mpl::not_<
5580  boost::mpl::or_<
5581  boost::proto::is_extension<field_indirect<T,M> >,
5582  boost::proto::is_extension<T >
5583  >
5584  >
5585  >,
5586  boost::proto::tag::multiplies,
5587  field_indirect<T,M> const &,
5588  T const &
5589 >::type /* const */
5590 operator* (field_indirect<T,M> const &left, T const &right)
5591 {
5592  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect<T,M> const &, T const &>()(left, right);
5593 }
5594 #endif // BOOST_VERSION
5595 template<class T, class M>
5596 #if BOOST_VERSION < 104601
5597 typename
5598 boost::proto::detail::enable_binary<
5599  field_domain,
5600  is_field<field_indirect_const<T,M> >,
5601  field_indirect_const<T,M>,
5602  is_field<int >,
5603  int,
5604  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5605  ::impl<const field_indirect_const<T,M>&, const int&>::result_type const
5606 >::type
5607 operator* (const field_indirect_const<T,M>& l, const int& r)
5608 {
5609  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5610  ::impl<const field_indirect_const<T,M>&, const int&>() (l, r);
5611 }
5612 #else // BOOST_VERSION >= 104601
5613 typename boost::proto::detail::enable_binary<
5614  field_domain,
5615  field_domain::proto_grammar,
5616  boost::mpl::and_<
5617  boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<int > >,
5618  boost::mpl::not_<
5619  boost::mpl::or_<
5620  boost::proto::is_extension<field_indirect_const<T,M> >,
5621  boost::proto::is_extension<int >
5622  >
5623  >
5624  >,
5625  boost::proto::tag::multiplies,
5626  field_indirect_const<T,M> const &,
5627  int const &
5628 >::type /* const */
5629 operator* (field_indirect_const<T,M> const &left, int const &right)
5630 {
5631  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect_const<T,M> const &, int const &>()(left, right);
5632 }
5633 #endif // BOOST_VERSION
5634 template<class T, class M>
5635 #if BOOST_VERSION < 104601
5636 typename
5637 boost::proto::detail::enable_binary<
5638  field_domain,
5639  is_field<field_indirect_const<T,M> >,
5640  field_indirect_const<T,M>,
5641  is_field<T >,
5642  T,
5643  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5644  ::impl<const field_indirect_const<T,M>&, const T&>::result_type const
5645 >::type
5646 operator* (const field_indirect_const<T,M>& l, const T& r)
5647 {
5648  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5649  ::impl<const field_indirect_const<T,M>&, const T&>() (l, r);
5650 }
5651 #else // BOOST_VERSION >= 104601
5652 typename boost::proto::detail::enable_binary<
5653  field_domain,
5654  field_domain::proto_grammar,
5655  boost::mpl::and_<
5656  boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<T > >,
5657  boost::mpl::not_<
5658  boost::mpl::or_<
5659  boost::proto::is_extension<field_indirect_const<T,M> >,
5660  boost::proto::is_extension<T >
5661  >
5662  >
5663  >,
5664  boost::proto::tag::multiplies,
5665  field_indirect_const<T,M> const &,
5666  T const &
5667 >::type /* const */
5668 operator* (field_indirect_const<T,M> const &left, T const &right)
5669 {
5670  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_indirect_const<T,M> const &, T const &>()(left, right);
5671 }
5672 #endif // BOOST_VERSION
5673 template<class T, class M>
5674 #if BOOST_VERSION < 104601
5675 typename
5676 boost::proto::detail::enable_binary<
5677  field_domain,
5678  is_field<field_component<T,M> >,
5679  field_component<T,M>,
5680  is_field<int >,
5681  int,
5682  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5683  ::impl<const field_component<T,M>&, const int&>::result_type const
5684 >::type
5685 operator* (const field_component<T,M>& l, const int& r)
5686 {
5687  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5688  ::impl<const field_component<T,M>&, const int&>() (l, r);
5689 }
5690 #else // BOOST_VERSION >= 104601
5691 typename boost::proto::detail::enable_binary<
5692  field_domain,
5693  field_domain::proto_grammar,
5694  boost::mpl::and_<
5695  boost::mpl::or_<is_field<field_component<T,M> >, is_field<int > >,
5696  boost::mpl::not_<
5697  boost::mpl::or_<
5698  boost::proto::is_extension<field_component<T,M> >,
5699  boost::proto::is_extension<int >
5700  >
5701  >
5702  >,
5703  boost::proto::tag::multiplies,
5704  field_component<T,M> const &,
5705  int const &
5706 >::type /* const */
5707 operator* (field_component<T,M> const &left, int const &right)
5708 {
5709  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component<T,M> const &, int const &>()(left, right);
5710 }
5711 #endif // BOOST_VERSION
5712 template<class T, class M>
5713 #if BOOST_VERSION < 104601
5714 typename
5715 boost::proto::detail::enable_binary<
5716  field_domain,
5717  is_field<field_component<T,M> >,
5718  field_component<T,M>,
5719  is_field<T >,
5720  T,
5721  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5722  ::impl<const field_component<T,M>&, const T&>::result_type const
5723 >::type
5724 operator* (const field_component<T,M>& l, const T& r)
5725 {
5726  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5727  ::impl<const field_component<T,M>&, const T&>() (l, r);
5728 }
5729 #else // BOOST_VERSION >= 104601
5730 typename boost::proto::detail::enable_binary<
5731  field_domain,
5732  field_domain::proto_grammar,
5733  boost::mpl::and_<
5734  boost::mpl::or_<is_field<field_component<T,M> >, is_field<T > >,
5735  boost::mpl::not_<
5736  boost::mpl::or_<
5737  boost::proto::is_extension<field_component<T,M> >,
5738  boost::proto::is_extension<T >
5739  >
5740  >
5741  >,
5742  boost::proto::tag::multiplies,
5743  field_component<T,M> const &,
5744  T const &
5745 >::type /* const */
5746 operator* (field_component<T,M> const &left, T const &right)
5747 {
5748  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component<T,M> const &, T const &>()(left, right);
5749 }
5750 #endif // BOOST_VERSION
5751 template<class T, class M>
5752 #if BOOST_VERSION < 104601
5753 typename
5754 boost::proto::detail::enable_binary<
5755  field_domain,
5756  is_field<field_component_const<T,M> >,
5757  field_component_const<T,M>,
5758  is_field<int >,
5759  int,
5760  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5761  ::impl<const field_component_const<T,M>&, const int&>::result_type const
5762 >::type
5763 operator* (const field_component_const<T,M>& l, const int& r)
5764 {
5765  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5766  ::impl<const field_component_const<T,M>&, const int&>() (l, r);
5767 }
5768 #else // BOOST_VERSION >= 104601
5769 typename boost::proto::detail::enable_binary<
5770  field_domain,
5771  field_domain::proto_grammar,
5772  boost::mpl::and_<
5773  boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<int > >,
5774  boost::mpl::not_<
5775  boost::mpl::or_<
5776  boost::proto::is_extension<field_component_const<T,M> >,
5777  boost::proto::is_extension<int >
5778  >
5779  >
5780  >,
5781  boost::proto::tag::multiplies,
5782  field_component_const<T,M> const &,
5783  int const &
5784 >::type /* const */
5785 operator* (field_component_const<T,M> const &left, int const &right)
5786 {
5787  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component_const<T,M> const &, int const &>()(left, right);
5788 }
5789 #endif // BOOST_VERSION
5790 template<class T, class M>
5791 #if BOOST_VERSION < 104601
5792 typename
5793 boost::proto::detail::enable_binary<
5794  field_domain,
5795  is_field<field_component_const<T,M> >,
5796  field_component_const<T,M>,
5797  is_field<T >,
5798  T,
5799  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5800  ::impl<const field_component_const<T,M>&, const T&>::result_type const
5801 >::type
5802 operator* (const field_component_const<T,M>& l, const T& r)
5803 {
5804  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5805  ::impl<const field_component_const<T,M>&, const T&>() (l, r);
5806 }
5807 #else // BOOST_VERSION >= 104601
5808 typename boost::proto::detail::enable_binary<
5809  field_domain,
5810  field_domain::proto_grammar,
5811  boost::mpl::and_<
5812  boost::mpl::or_<is_field<field_component_const<T,M> >, is_field<T > >,
5813  boost::mpl::not_<
5814  boost::mpl::or_<
5815  boost::proto::is_extension<field_component_const<T,M> >,
5816  boost::proto::is_extension<T >
5817  >
5818  >
5819  >,
5820  boost::proto::tag::multiplies,
5821  field_component_const<T,M> const &,
5822  T const &
5823 >::type /* const */
5824 operator* (field_component_const<T,M> const &left, T const &right)
5825 {
5826  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_component_const<T,M> const &, T const &>()(left, right);
5827 }
5828 #endif // BOOST_VERSION
5829 template<class Expr>
5830 #if BOOST_VERSION < 104601
5831 typename
5832 boost::proto::detail::enable_binary<
5833  field_domain,
5834  is_field<int >,
5835  int,
5836  is_field<field_expr<Expr> >,
5837  field_expr<Expr>,
5838  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5839  ::impl<const int&, const field_expr<Expr>&>::result_type const
5840 >::type
5841 operator* (const int& l, const field_expr<Expr>& r)
5842 {
5843  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5844  ::impl<const int&, const field_expr<Expr>&>() (l, r);
5845 }
5846 #else // BOOST_VERSION >= 104601
5847 typename boost::proto::detail::enable_binary<
5848  field_domain,
5849  field_domain::proto_grammar,
5850  boost::mpl::and_<
5851  boost::mpl::or_<is_field<int >, is_field<field_expr<Expr> > >,
5852  boost::mpl::not_<
5853  boost::mpl::or_<
5854  boost::proto::is_extension<int >,
5855  boost::proto::is_extension<field_expr<Expr> >
5856  >
5857  >
5858  >,
5859  boost::proto::tag::multiplies,
5860  int const &,
5861  field_expr<Expr> const &
5862 >::type /* const */
5863 operator* (int const &left, field_expr<Expr> const &right)
5864 {
5865  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, int const &, field_expr<Expr> const &>()(left, right);
5866 }
5867 #endif // BOOST_VERSION
5868 template<class Expr>
5869 #if BOOST_VERSION < 104601
5870 typename
5871 boost::proto::detail::enable_binary<
5872  field_domain,
5873  is_field<field_expr<Expr> >,
5874  field_expr<Expr>,
5875  is_field<int >,
5876  int,
5877  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5878  ::impl<const field_expr<Expr>&, const int&>::result_type const
5879 >::type
5880 operator* (const field_expr<Expr>& l, const int& r)
5881 {
5882  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5883  ::impl<const field_expr<Expr>&, const int&>() (l, r);
5884 }
5885 #else // BOOST_VERSION >= 104601
5886 typename boost::proto::detail::enable_binary<
5887  field_domain,
5888  field_domain::proto_grammar,
5889  boost::mpl::and_<
5890  boost::mpl::or_<is_field<field_expr<Expr> >, is_field<int > >,
5891  boost::mpl::not_<
5892  boost::mpl::or_<
5893  boost::proto::is_extension<field_expr<Expr> >,
5894  boost::proto::is_extension<int >
5895  >
5896  >
5897  >,
5898  boost::proto::tag::multiplies,
5899  field_expr<Expr> const &,
5900  int const &
5901 >::type /* const */
5902 operator* (field_expr<Expr> const &left, int const &right)
5903 {
5904  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_expr<Expr> const &, int const &>()(left, right);
5905 }
5906 #endif // BOOST_VERSION
5907 template<class T, class Expr>
5908 #if BOOST_VERSION < 104601
5909 typename
5910 boost::proto::detail::enable_binary<
5911  field_domain,
5912  is_field<T >,
5913  T,
5914  is_field<field_expr<Expr> >,
5915  field_expr<Expr>,
5916  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5917  ::impl<const T&, const field_expr<Expr>&>::result_type const
5918 >::type
5919 operator* (const T& l, const field_expr<Expr>& r)
5920 {
5921  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5922  ::impl<const T&, const field_expr<Expr>&>() (l, r);
5923 }
5924 #else // BOOST_VERSION >= 104601
5925 typename boost::proto::detail::enable_binary<
5926  field_domain,
5927  field_domain::proto_grammar,
5928  boost::mpl::and_<
5929  boost::mpl::or_<is_field<T >, is_field<field_expr<Expr> > >,
5930  boost::mpl::not_<
5931  boost::mpl::or_<
5932  boost::proto::is_extension<T >,
5933  boost::proto::is_extension<field_expr<Expr> >
5934  >
5935  >
5936  >,
5937  boost::proto::tag::multiplies,
5938  T const &,
5939  field_expr<Expr> const &
5940 >::type /* const */
5941 operator* (T const &left, field_expr<Expr> const &right)
5942 {
5943  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, T const &, field_expr<Expr> const &>()(left, right);
5944 }
5945 #endif // BOOST_VERSION
5946 template<class T, class Expr>
5947 #if BOOST_VERSION < 104601
5948 typename
5949 boost::proto::detail::enable_binary<
5950  field_domain,
5951  is_field<field_expr<Expr> >,
5952  field_expr<Expr>,
5953  is_field<T >,
5954  T,
5955  typename boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5956  ::impl<const field_expr<Expr>&, const T&>::result_type const
5957 >::type
5958 operator* (const field_expr<Expr>& l, const T& r)
5959 {
5960  return boost::proto::functional::make_expr<boost::proto::tag::multiplies, field_domain>
5961  ::impl<const field_expr<Expr>&, const T&>() (l, r);
5962 }
5963 #else // BOOST_VERSION >= 104601
5964 typename boost::proto::detail::enable_binary<
5965  field_domain,
5966  field_domain::proto_grammar,
5967  boost::mpl::and_<
5968  boost::mpl::or_<is_field<field_expr<Expr> >, is_field<T > >,
5969  boost::mpl::not_<
5970  boost::mpl::or_<
5971  boost::proto::is_extension<field_expr<Expr> >,
5972  boost::proto::is_extension<T >
5973  >
5974  >
5975  >,
5976  boost::proto::tag::multiplies,
5977  field_expr<Expr> const &,
5978  T const &
5979 >::type /* const */
5980 operator* (field_expr<Expr> const &left, T const &right)
5981 {
5982  return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, field_domain, field_expr<Expr> const &, T const &>()(left, right);
5983 }
5984 #endif // BOOST_VERSION
5985 template<class T, class M>
5986 #if BOOST_VERSION < 104601
5987 typename
5988 boost::proto::detail::enable_binary<
5989  field_domain,
5990  is_field<int >,
5991  int,
5992  is_field<field_basic<T,M> >,
5993  field_basic<T,M>,
5994  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
5995  ::impl<const int&, const field_basic<T,M>&>::result_type const
5996 >::type
5997 operator/ (const int& l, const field_basic<T,M>& r)
5998 {
5999  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6000  ::impl<const int&, const field_basic<T,M>&>() (l, r);
6001 }
6002 #else // BOOST_VERSION >= 104601
6003 typename boost::proto::detail::enable_binary<
6004  field_domain,
6005  field_domain::proto_grammar,
6006  boost::mpl::and_<
6007  boost::mpl::or_<is_field<int >, is_field<field_basic<T,M> > >,
6008  boost::mpl::not_<
6009  boost::mpl::or_<
6010  boost::proto::is_extension<int >,
6011  boost::proto::is_extension<field_basic<T,M> >
6012  >
6013  >
6014  >,
6015  boost::proto::tag::divides,
6016  int const &,
6017  field_basic<T,M> const &
6018 >::type /* const */
6019 operator/ (int const &left, field_basic<T,M> const &right)
6020 {
6021  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, int const &, field_basic<T,M> const &>()(left, right);
6022 }
6023 #endif // BOOST_VERSION
6024 template<class T, class M>
6025 #if BOOST_VERSION < 104601
6026 typename
6027 boost::proto::detail::enable_binary<
6028  field_domain,
6029  is_field<T >,
6030  T,
6031  is_field<field_basic<T,M> >,
6032  field_basic<T,M>,
6033  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6034  ::impl<const T&, const field_basic<T,M>&>::result_type const
6035 >::type
6036 operator/ (const T& l, const field_basic<T,M>& r)
6037 {
6038  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6039  ::impl<const T&, const field_basic<T,M>&>() (l, r);
6040 }
6041 #else // BOOST_VERSION >= 104601
6042 typename boost::proto::detail::enable_binary<
6043  field_domain,
6044  field_domain::proto_grammar,
6045  boost::mpl::and_<
6046  boost::mpl::or_<is_field<T >, is_field<field_basic<T,M> > >,
6047  boost::mpl::not_<
6048  boost::mpl::or_<
6049  boost::proto::is_extension<T >,
6050  boost::proto::is_extension<field_basic<T,M> >
6051  >
6052  >
6053  >,
6054  boost::proto::tag::divides,
6055  T const &,
6056  field_basic<T,M> const &
6057 >::type /* const */
6058 operator/ (T const &left, field_basic<T,M> const &right)
6059 {
6060  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, T const &, field_basic<T,M> const &>()(left, right);
6061 }
6062 #endif // BOOST_VERSION
6063 template<class T, class M>
6064 #if BOOST_VERSION < 104601
6065 typename
6066 boost::proto::detail::enable_binary<
6067  field_domain,
6068  is_field<int >,
6069  int,
6070  is_field<field_indirect<T,M> >,
6071  field_indirect<T,M>,
6072  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6073  ::impl<const int&, const field_indirect<T,M>&>::result_type const
6074 >::type
6075 operator/ (const int& l, const field_indirect<T,M>& r)
6076 {
6077  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6078  ::impl<const int&, const field_indirect<T,M>&>() (l, r);
6079 }
6080 #else // BOOST_VERSION >= 104601
6081 typename boost::proto::detail::enable_binary<
6082  field_domain,
6083  field_domain::proto_grammar,
6084  boost::mpl::and_<
6085  boost::mpl::or_<is_field<int >, is_field<field_indirect<T,M> > >,
6086  boost::mpl::not_<
6087  boost::mpl::or_<
6088  boost::proto::is_extension<int >,
6089  boost::proto::is_extension<field_indirect<T,M> >
6090  >
6091  >
6092  >,
6093  boost::proto::tag::divides,
6094  int const &,
6095  field_indirect<T,M> const &
6096 >::type /* const */
6097 operator/ (int const &left, field_indirect<T,M> const &right)
6098 {
6099  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, int const &, field_indirect<T,M> const &>()(left, right);
6100 }
6101 #endif // BOOST_VERSION
6102 template<class T, class M>
6103 #if BOOST_VERSION < 104601
6104 typename
6105 boost::proto::detail::enable_binary<
6106  field_domain,
6107  is_field<T >,
6108  T,
6109  is_field<field_indirect<T,M> >,
6110  field_indirect<T,M>,
6111  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6112  ::impl<const T&, const field_indirect<T,M>&>::result_type const
6113 >::type
6114 operator/ (const T& l, const field_indirect<T,M>& r)
6115 {
6116  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6117  ::impl<const T&, const field_indirect<T,M>&>() (l, r);
6118 }
6119 #else // BOOST_VERSION >= 104601
6120 typename boost::proto::detail::enable_binary<
6121  field_domain,
6122  field_domain::proto_grammar,
6123  boost::mpl::and_<
6124  boost::mpl::or_<is_field<T >, is_field<field_indirect<T,M> > >,
6125  boost::mpl::not_<
6126  boost::mpl::or_<
6127  boost::proto::is_extension<T >,
6128  boost::proto::is_extension<field_indirect<T,M> >
6129  >
6130  >
6131  >,
6132  boost::proto::tag::divides,
6133  T const &,
6134  field_indirect<T,M> const &
6135 >::type /* const */
6136 operator/ (T const &left, field_indirect<T,M> const &right)
6137 {
6138  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, T const &, field_indirect<T,M> const &>()(left, right);
6139 }
6140 #endif // BOOST_VERSION
6141 template<class T, class M>
6142 #if BOOST_VERSION < 104601
6143 typename
6144 boost::proto::detail::enable_binary<
6145  field_domain,
6146  is_field<int >,
6147  int,
6148  is_field<field_indirect_const<T,M> >,
6149  field_indirect_const<T,M>,
6150  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6151  ::impl<const int&, const field_indirect_const<T,M>&>::result_type const
6152 >::type
6153 operator/ (const int& l, const field_indirect_const<T,M>& r)
6154 {
6155  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6156  ::impl<const int&, const field_indirect_const<T,M>&>() (l, r);
6157 }
6158 #else // BOOST_VERSION >= 104601
6159 typename boost::proto::detail::enable_binary<
6160  field_domain,
6161  field_domain::proto_grammar,
6162  boost::mpl::and_<
6163  boost::mpl::or_<is_field<int >, is_field<field_indirect_const<T,M> > >,
6164  boost::mpl::not_<
6165  boost::mpl::or_<
6166  boost::proto::is_extension<int >,
6167  boost::proto::is_extension<field_indirect_const<T,M> >
6168  >
6169  >
6170  >,
6171  boost::proto::tag::divides,
6172  int const &,
6173  field_indirect_const<T,M> const &
6174 >::type /* const */
6175 operator/ (int const &left, field_indirect_const<T,M> const &right)
6176 {
6177  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, int const &, field_indirect_const<T,M> const &>()(left, right);
6178 }
6179 #endif // BOOST_VERSION
6180 template<class T, class M>
6181 #if BOOST_VERSION < 104601
6182 typename
6183 boost::proto::detail::enable_binary<
6184  field_domain,
6185  is_field<T >,
6186  T,
6187  is_field<field_indirect_const<T,M> >,
6188  field_indirect_const<T,M>,
6189  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6190  ::impl<const T&, const field_indirect_const<T,M>&>::result_type const
6191 >::type
6192 operator/ (const T& l, const field_indirect_const<T,M>& r)
6193 {
6194  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6195  ::impl<const T&, const field_indirect_const<T,M>&>() (l, r);
6196 }
6197 #else // BOOST_VERSION >= 104601
6198 typename boost::proto::detail::enable_binary<
6199  field_domain,
6200  field_domain::proto_grammar,
6201  boost::mpl::and_<
6202  boost::mpl::or_<is_field<T >, is_field<field_indirect_const<T,M> > >,
6203  boost::mpl::not_<
6204  boost::mpl::or_<
6205  boost::proto::is_extension<T >,
6206  boost::proto::is_extension<field_indirect_const<T,M> >
6207  >
6208  >
6209  >,
6210  boost::proto::tag::divides,
6211  T const &,
6212  field_indirect_const<T,M> const &
6213 >::type /* const */
6214 operator/ (T const &left, field_indirect_const<T,M> const &right)
6215 {
6216  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, T const &, field_indirect_const<T,M> const &>()(left, right);
6217 }
6218 #endif // BOOST_VERSION
6219 template<class T, class M>
6220 #if BOOST_VERSION < 104601
6221 typename
6222 boost::proto::detail::enable_binary<
6223  field_domain,
6224  is_field<int >,
6225  int,
6226  is_field<field_component<T,M> >,
6227  field_component<T,M>,
6228  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6229  ::impl<const int&, const field_component<T,M>&>::result_type const
6230 >::type
6231 operator/ (const int& l, const field_component<T,M>& r)
6232 {
6233  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6234  ::impl<const int&, const field_component<T,M>&>() (l, r);
6235 }
6236 #else // BOOST_VERSION >= 104601
6237 typename boost::proto::detail::enable_binary<
6238  field_domain,
6239  field_domain::proto_grammar,
6240  boost::mpl::and_<
6241  boost::mpl::or_<is_field<int >, is_field<field_component<T,M> > >,
6242  boost::mpl::not_<
6243  boost::mpl::or_<
6244  boost::proto::is_extension<int >,
6245  boost::proto::is_extension<field_component<T,M> >
6246  >
6247  >
6248  >,
6249  boost::proto::tag::divides,
6250  int const &,
6251  field_component<T,M> const &
6252 >::type /* const */
6253 operator/ (int const &left, field_component<T,M> const &right)
6254 {
6255  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, int const &, field_component<T,M> const &>()(left, right);
6256 }
6257 #endif // BOOST_VERSION
6258 template<class T, class M>
6259 #if BOOST_VERSION < 104601
6260 typename
6261 boost::proto::detail::enable_binary<
6262  field_domain,
6263  is_field<T >,
6264  T,
6265  is_field<field_component<T,M> >,
6266  field_component<T,M>,
6267  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6268  ::impl<const T&, const field_component<T,M>&>::result_type const
6269 >::type
6270 operator/ (const T& l, const field_component<T,M>& r)
6271 {
6272  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6273  ::impl<const T&, const field_component<T,M>&>() (l, r);
6274 }
6275 #else // BOOST_VERSION >= 104601
6276 typename boost::proto::detail::enable_binary<
6277  field_domain,
6278  field_domain::proto_grammar,
6279  boost::mpl::and_<
6280  boost::mpl::or_<is_field<T >, is_field<field_component<T,M> > >,
6281  boost::mpl::not_<
6282  boost::mpl::or_<
6283  boost::proto::is_extension<T >,
6284  boost::proto::is_extension<field_component<T,M> >
6285  >
6286  >
6287  >,
6288  boost::proto::tag::divides,
6289  T const &,
6290  field_component<T,M> const &
6291 >::type /* const */
6292 operator/ (T const &left, field_component<T,M> const &right)
6293 {
6294  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, T const &, field_component<T,M> const &>()(left, right);
6295 }
6296 #endif // BOOST_VERSION
6297 template<class T, class M>
6298 #if BOOST_VERSION < 104601
6299 typename
6300 boost::proto::detail::enable_binary<
6301  field_domain,
6302  is_field<int >,
6303  int,
6304  is_field<field_component_const<T,M> >,
6305  field_component_const<T,M>,
6306  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6307  ::impl<const int&, const field_component_const<T,M>&>::result_type const
6308 >::type
6309 operator/ (const int& l, const field_component_const<T,M>& r)
6310 {
6311  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6312  ::impl<const int&, const field_component_const<T,M>&>() (l, r);
6313 }
6314 #else // BOOST_VERSION >= 104601
6315 typename boost::proto::detail::enable_binary<
6316  field_domain,
6317  field_domain::proto_grammar,
6318  boost::mpl::and_<
6319  boost::mpl::or_<is_field<int >, is_field<field_component_const<T,M> > >,
6320  boost::mpl::not_<
6321  boost::mpl::or_<
6322  boost::proto::is_extension<int >,
6323  boost::proto::is_extension<field_component_const<T,M> >
6324  >
6325  >
6326  >,
6327  boost::proto::tag::divides,
6328  int const &,
6329  field_component_const<T,M> const &
6330 >::type /* const */
6331 operator/ (int const &left, field_component_const<T,M> const &right)
6332 {
6333  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, int const &, field_component_const<T,M> const &>()(left, right);
6334 }
6335 #endif // BOOST_VERSION
6336 template<class T, class M>
6337 #if BOOST_VERSION < 104601
6338 typename
6339 boost::proto::detail::enable_binary<
6340  field_domain,
6341  is_field<T >,
6342  T,
6343  is_field<field_component_const<T,M> >,
6344  field_component_const<T,M>,
6345  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6346  ::impl<const T&, const field_component_const<T,M>&>::result_type const
6347 >::type
6348 operator/ (const T& l, const field_component_const<T,M>& r)
6349 {
6350  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6351  ::impl<const T&, const field_component_const<T,M>&>() (l, r);
6352 }
6353 #else // BOOST_VERSION >= 104601
6354 typename boost::proto::detail::enable_binary<
6355  field_domain,
6356  field_domain::proto_grammar,
6357  boost::mpl::and_<
6358  boost::mpl::or_<is_field<T >, is_field<field_component_const<T,M> > >,
6359  boost::mpl::not_<
6360  boost::mpl::or_<
6361  boost::proto::is_extension<T >,
6362  boost::proto::is_extension<field_component_const<T,M> >
6363  >
6364  >
6365  >,
6366  boost::proto::tag::divides,
6367  T const &,
6368  field_component_const<T,M> const &
6369 >::type /* const */
6370 operator/ (T const &left, field_component_const<T,M> const &right)
6371 {
6372  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, T const &, field_component_const<T,M> const &>()(left, right);
6373 }
6374 #endif // BOOST_VERSION
6375 template<class T, class M>
6376 #if BOOST_VERSION < 104601
6377 typename
6378 boost::proto::detail::enable_binary<
6379  field_domain,
6380  is_field<field_basic<T,M> >,
6381  field_basic<T,M>,
6382  is_field<int >,
6383  int,
6384  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6385  ::impl<const field_basic<T,M>&, const int&>::result_type const
6386 >::type
6387 operator/ (const field_basic<T,M>& l, const int& r)
6388 {
6389  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6390  ::impl<const field_basic<T,M>&, const int&>() (l, r);
6391 }
6392 #else // BOOST_VERSION >= 104601
6393 typename boost::proto::detail::enable_binary<
6394  field_domain,
6395  field_domain::proto_grammar,
6396  boost::mpl::and_<
6397  boost::mpl::or_<is_field<field_basic<T,M> >, is_field<int > >,
6398  boost::mpl::not_<
6399  boost::mpl::or_<
6400  boost::proto::is_extension<field_basic<T,M> >,
6401  boost::proto::is_extension<int >
6402  >
6403  >
6404  >,
6405  boost::proto::tag::divides,
6406  field_basic<T,M> const &,
6407  int const &
6408 >::type /* const */
6409 operator/ (field_basic<T,M> const &left, int const &right)
6410 {
6411  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_basic<T,M> const &, int const &>()(left, right);
6412 }
6413 #endif // BOOST_VERSION
6414 template<class T, class M>
6415 #if BOOST_VERSION < 104601
6416 typename
6417 boost::proto::detail::enable_binary<
6418  field_domain,
6419  is_field<field_basic<T,M> >,
6420  field_basic<T,M>,
6421  is_field<T >,
6422  T,
6423  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6424  ::impl<const field_basic<T,M>&, const T&>::result_type const
6425 >::type
6426 operator/ (const field_basic<T,M>& l, const T& r)
6427 {
6428  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6429  ::impl<const field_basic<T,M>&, const T&>() (l, r);
6430 }
6431 #else // BOOST_VERSION >= 104601
6432 typename boost::proto::detail::enable_binary<
6433  field_domain,
6434  field_domain::proto_grammar,
6435  boost::mpl::and_<
6436  boost::mpl::or_<is_field<field_basic<T,M> >, is_field<T > >,
6437  boost::mpl::not_<
6438  boost::mpl::or_<
6439  boost::proto::is_extension<field_basic<T,M> >,
6440  boost::proto::is_extension<T >
6441  >
6442  >
6443  >,
6444  boost::proto::tag::divides,
6445  field_basic<T,M> const &,
6446  T const &
6447 >::type /* const */
6448 operator/ (field_basic<T,M> const &left, T const &right)
6449 {
6450  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_basic<T,M> const &, T const &>()(left, right);
6451 }
6452 #endif // BOOST_VERSION
6453 template<class T, class M>
6454 #if BOOST_VERSION < 104601
6455 typename
6456 boost::proto::detail::enable_binary<
6457  field_domain,
6458  is_field<field_indirect<T,M> >,
6459  field_indirect<T,M>,
6460  is_field<int >,
6461  int,
6462  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6463  ::impl<const field_indirect<T,M>&, const int&>::result_type const
6464 >::type
6465 operator/ (const field_indirect<T,M>& l, const int& r)
6466 {
6467  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6468  ::impl<const field_indirect<T,M>&, const int&>() (l, r);
6469 }
6470 #else // BOOST_VERSION >= 104601
6471 typename boost::proto::detail::enable_binary<
6472  field_domain,
6473  field_domain::proto_grammar,
6474  boost::mpl::and_<
6475  boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<int > >,
6476  boost::mpl::not_<
6477  boost::mpl::or_<
6478  boost::proto::is_extension<field_indirect<T,M> >,
6479  boost::proto::is_extension<int >
6480  >
6481  >
6482  >,
6483  boost::proto::tag::divides,
6484  field_indirect<T,M> const &,
6485  int const &
6486 >::type /* const */
6487 operator/ (field_indirect<T,M> const &left, int const &right)
6488 {
6489  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect<T,M> const &, int const &>()(left, right);
6490 }
6491 #endif // BOOST_VERSION
6492 template<class T, class M>
6493 #if BOOST_VERSION < 104601
6494 typename
6495 boost::proto::detail::enable_binary<
6496  field_domain,
6497  is_field<field_indirect<T,M> >,
6498  field_indirect<T,M>,
6499  is_field<T >,
6500  T,
6501  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6502  ::impl<const field_indirect<T,M>&, const T&>::result_type const
6503 >::type
6504 operator/ (const field_indirect<T,M>& l, const T& r)
6505 {
6506  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6507  ::impl<const field_indirect<T,M>&, const T&>() (l, r);
6508 }
6509 #else // BOOST_VERSION >= 104601
6510 typename boost::proto::detail::enable_binary<
6511  field_domain,
6512  field_domain::proto_grammar,
6513  boost::mpl::and_<
6514  boost::mpl::or_<is_field<field_indirect<T,M> >, is_field<T > >,
6515  boost::mpl::not_<
6516  boost::mpl::or_<
6517  boost::proto::is_extension<field_indirect<T,M> >,
6518  boost::proto::is_extension<T >
6519  >
6520  >
6521  >,
6522  boost::proto::tag::divides,
6523  field_indirect<T,M> const &,
6524  T const &
6525 >::type /* const */
6526 operator/ (field_indirect<T,M> const &left, T const &right)
6527 {
6528  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect<T,M> const &, T const &>()(left, right);
6529 }
6530 #endif // BOOST_VERSION
6531 template<class T, class M>
6532 #if BOOST_VERSION < 104601
6533 typename
6534 boost::proto::detail::enable_binary<
6535  field_domain,
6536  is_field<field_indirect_const<T,M> >,
6537  field_indirect_const<T,M>,
6538  is_field<int >,
6539  int,
6540  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6541  ::impl<const field_indirect_const<T,M>&, const int&>::result_type const
6542 >::type
6543 operator/ (const field_indirect_const<T,M>& l, const int& r)
6544 {
6545  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6546  ::impl<const field_indirect_const<T,M>&, const int&>() (l, r);
6547 }
6548 #else // BOOST_VERSION >= 104601
6549 typename boost::proto::detail::enable_binary<
6550  field_domain,
6551  field_domain::proto_grammar,
6552  boost::mpl::and_<
6553  boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<int > >,
6554  boost::mpl::not_<
6555  boost::mpl::or_<
6556  boost::proto::is_extension<field_indirect_const<T,M> >,
6557  boost::proto::is_extension<int >
6558  >
6559  >
6560  >,
6561  boost::proto::tag::divides,
6562  field_indirect_const<T,M> const &,
6563  int const &
6564 >::type /* const */
6565 operator/ (field_indirect_const<T,M> const &left, int const &right)
6566 {
6567  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect_const<T,M> const &, int const &>()(left, right);
6568 }
6569 #endif // BOOST_VERSION
6570 template<class T, class M>
6571 #if BOOST_VERSION < 104601
6572 typename
6573 boost::proto::detail::enable_binary<
6574  field_domain,
6575  is_field<field_indirect_const<T,M> >,
6576  field_indirect_const<T,M>,
6577  is_field<T >,
6578  T,
6579  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6580  ::impl<const field_indirect_const<T,M>&, const T&>::result_type const
6581 >::type
6582 operator/ (const field_indirect_const<T,M>& l, const T& r)
6583 {
6584  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6585  ::impl<const field_indirect_const<T,M>&, const T&>() (l, r);
6586 }
6587 #else // BOOST_VERSION >= 104601
6588 typename boost::proto::detail::enable_binary<
6589  field_domain,
6590  field_domain::proto_grammar,
6591  boost::mpl::and_<
6592  boost::mpl::or_<is_field<field_indirect_const<T,M> >, is_field<T > >,
6593  boost::mpl::not_<
6594  boost::mpl::or_<
6595  boost::proto::is_extension<field_indirect_const<T,M> >,
6596  boost::proto::is_extension<T >
6597  >
6598  >
6599  >,
6600  boost::proto::tag::divides,
6601  field_indirect_const<T,M> const &,
6602  T const &
6603 >::type /* const */
6604 operator/ (field_indirect_const<T,M> const &left, T const &right)
6605 {
6606  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_indirect_const<T,M> const &, T const &>()(left, right);
6607 }
6608 #endif // BOOST_VERSION
6609 template<class T, class M>
6610 #if BOOST_VERSION < 104601
6611 typename
6612 boost::proto::detail::enable_binary<
6613  field_domain,
6614  is_field<field_component<T,M> >,
6615  field_component<T,M>,
6616  is_field<int >,
6617  int,
6618  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6619  ::impl<const field_component<T,M>&, const int&>::result_type const
6620 >::type
6621 operator/ (const field_component<T,M>& l, const int& r)
6622 {
6623  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6624  ::impl<const field_component<T,M>&, const int&>() (l, r);
6625 }
6626 #else // BOOST_VERSION >= 104601
6627 typename boost::proto::detail::enable_binary<
6628  field_domain,
6629  field_domain::proto_grammar,
6630  boost::mpl::and_<
6631  boost::mpl::or_<is_field<field_component<T,M> >, is_field<int > >,
6632  boost::mpl::not_<
6633  boost::mpl::or_<
6634  boost::proto::is_extension<field_component<T,M> >,
6635  boost::proto::is_extension<int >
6636  >
6637  >
6638  >,
6639  boost::proto::tag::divides,
6640  field_component<T,M> const &,
6641  int const &
6642 >::type /* const */
6643 operator/ (field_component<T,M> const &left, int const &right)
6644 {
6645  return boost::proto::detail::make_expr_<boost::proto::tag::divides, field_domain, field_component<T,M> const &, int const &>()(left, right);
6646 }
6647 #endif // BOOST_VERSION
6648 template<class T, class M>
6649 #if BOOST_VERSION < 104601
6650 typename
6651 boost::proto::detail::enable_binary<
6652  field_domain,
6653  is_field<field_component<T,M> >,
6654  field_component<T,M>,
6655  is_field<T >,
6656  T,
6657  typename boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6658  ::impl<const field_component<T,M>&, const T&>::result_type const
6659 >::type
6660 operator/ (const field_component<T,M>& l, const T& r)
6661 {
6662  return boost::proto::functional::make_expr<boost::proto::tag::divides, field_domain>
6663  ::impl<const field_component<T,M>&, const T&>() (l, r);
6664 }
6665 #else // BOOST_VERSION >= 104601
6666 typename boost::proto::detail::enable_binary<
6667  field_domain,
6668  field_domain::proto_grammar,
6669  boost::mpl::and_<
6670  boost::mpl::or_<is_field<field_component<T,M> >, is_field<T > >,
6671  boost::mpl::not_<
6672  boost::mpl::or_<
6673  boost::proto::is_extension<field_component<T,M> >,
6674  boost::proto::is_extension<T >
6675  >
6676  >
6677  >,
6678  boost::proto::tag::divides,
6679  field_component<T,M> const &,
6680  T const &
6681 >::type /* const */
6682