CodeMover prototype
[dyninst.git] / external / boost / foreach.hpp
1 ///////////////////////////////////////////////////////////////////////////////\r
2 // foreach.hpp header file\r
3 //\r
4 // Copyright 2004 Eric Niebler.\r
5 // Distributed under the Boost Software License, Version 1.0. (See\r
6 // accompanying file LICENSE_1_0.txt or copy at\r
7 // http://www.boost.org/LICENSE_1_0.txt)\r
8 // See http://www.boost.org/libs/foreach for documentation\r
9 //\r
10 // Credits:\r
11 //  Anson Tsao        - for the initial inspiration and several good suggestions.\r
12 //  Thorsten Ottosen  - for Boost.Range, and for suggesting a way to detect\r
13 //                      const-qualified rvalues at compile time on VC7.1+\r
14 //  Russell Hind      - For help porting to Borland\r
15 //  Alisdair Meredith - For help porting to Borland\r
16 //  Stefan Slapeta    - For help porting to Intel\r
17 //  David Jenkins     - For help finding a Microsoft Code Analysis bug\r
18 \r
19 #ifndef BOOST_FOREACH\r
20 \r
21 // MS compatible compilers support #pragma once\r
22 #if defined(_MSC_VER) && (_MSC_VER >= 1020)\r
23 # pragma once\r
24 #endif\r
25 \r
26 #include <cstddef>\r
27 #include <utility>  // for std::pair\r
28 \r
29 #include <boost/config.hpp>\r
30 #include <boost/detail/workaround.hpp>\r
31 \r
32 // Some compilers let us detect even const-qualified rvalues at compile-time\r
33 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1310) && !defined(_PREFAST_)                                 \\r
34  || (BOOST_WORKAROUND(__GNUC__, >= 4) && !defined(BOOST_INTEL))                                 \\r
35  || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ >= 4) && !defined(BOOST_INTEL))\r
36 # define BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION\r
37 #else\r
38 // Some compilers allow temporaries to be bound to non-const references.\r
39 // These compilers make it impossible to for BOOST_FOREACH to detect\r
40 // temporaries and avoid reevaluation of the collection expression.\r
41 # if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)                                                      \\r
42   || BOOST_WORKAROUND(__BORLANDC__, < 0x593)                                                    \\r
43   || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER))                   \\r
44   || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x570))                                      \\r
45   || BOOST_WORKAROUND(__DECCXX_VER, <= 60590042)\r
46 #  define BOOST_FOREACH_NO_RVALUE_DETECTION\r
47 # endif\r
48 // Some compilers do not correctly implement the lvalue/rvalue conversion\r
49 // rules of the ternary conditional operator.\r
50 # if defined(BOOST_FOREACH_NO_RVALUE_DETECTION)                                                 \\r
51   || defined(BOOST_NO_SFINAE)                                                                   \\r
52   || BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400))                                        \\r
53   || BOOST_WORKAROUND(BOOST_INTEL_WIN, <= 810)                                                  \\r
54   || BOOST_WORKAROUND(__GNUC__, < 3)                                                            \\r
55   || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ <= 2))                                \\r
56   || (BOOST_WORKAROUND(__GNUC__, == 3) && (__GNUC_MINOR__ <= 3) && defined(__APPLE_CC__))       \\r
57   || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))                                         \\r
58   || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))                                      \\r
59   || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x590))\r
60 #  define BOOST_FOREACH_NO_CONST_RVALUE_DETECTION\r
61 # else\r
62 #  define BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION\r
63 # endif\r
64 #endif\r
65 \r
66 #include <boost/mpl/if.hpp>\r
67 #include <boost/mpl/assert.hpp>\r
68 #include <boost/mpl/logical.hpp>\r
69 #include <boost/mpl/eval_if.hpp>\r
70 #include <boost/noncopyable.hpp>\r
71 #include <boost/range/end.hpp>\r
72 #include <boost/range/begin.hpp>\r
73 #include <boost/range/rend.hpp>\r
74 #include <boost/range/rbegin.hpp>\r
75 #include <boost/range/iterator.hpp>\r
76 #include <boost/range/reverse_iterator.hpp>\r
77 #include <boost/type_traits/is_array.hpp>\r
78 #include <boost/type_traits/is_const.hpp>\r
79 #include <boost/type_traits/is_abstract.hpp>\r
80 #include <boost/type_traits/is_base_and_derived.hpp>\r
81 #include <boost/iterator/iterator_traits.hpp>\r
82 #include <boost/utility/addressof.hpp>\r
83 \r
84 #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION\r
85 # include <new>\r
86 # include <boost/aligned_storage.hpp>\r
87 # include <boost/utility/enable_if.hpp>\r
88 # include <boost/type_traits/remove_const.hpp>\r
89 #endif\r
90 \r
91 // This must be at global scope, hence the uglified name\r
92 enum boost_foreach_argument_dependent_lookup_hack\r
93 {\r
94     boost_foreach_argument_dependent_lookup_hack_value\r
95 };\r
96 \r
97 namespace boost\r
98 {\r
99 \r
100 // forward declarations for iterator_range\r
101 template<typename T>\r
102 class iterator_range;\r
103 \r
104 // forward declarations for sub_range\r
105 template<typename T>\r
106 class sub_range;\r
107 \r
108 namespace foreach\r
109 {\r
110     ///////////////////////////////////////////////////////////////////////////////\r
111     // in_range\r
112     //\r
113     template<typename T>\r
114     inline std::pair<T, T> in_range(T begin, T end)\r
115     {\r
116         return std::make_pair(begin, end);\r
117     }\r
118 \r
119     ///////////////////////////////////////////////////////////////////////////////\r
120     // boost::foreach::tag\r
121     //\r
122     typedef boost_foreach_argument_dependent_lookup_hack tag;\r
123 \r
124     ///////////////////////////////////////////////////////////////////////////////\r
125     // boost::foreach::is_lightweight_proxy\r
126     //   Specialize this for user-defined collection types if they are inexpensive to copy.\r
127     //   This tells BOOST_FOREACH it can avoid the rvalue/lvalue detection stuff.\r
128     template<typename T>\r
129     struct is_lightweight_proxy\r
130       : boost::mpl::false_\r
131     {\r
132     };\r
133 \r
134     ///////////////////////////////////////////////////////////////////////////////\r
135     // boost::foreach::is_noncopyable\r
136     //   Specialize this for user-defined collection types if they cannot be copied.\r
137     //   This also tells BOOST_FOREACH to avoid the rvalue/lvalue detection stuff.\r
138     template<typename T>\r
139     struct is_noncopyable\r
140     #if !defined(BOOST_BROKEN_IS_BASE_AND_DERIVED) && !defined(BOOST_NO_IS_ABSTRACT)\r
141       : boost::mpl::or_<\r
142             boost::is_abstract<T>\r
143           , boost::is_base_and_derived<boost::noncopyable, T>\r
144         >\r
145     #elif !defined(BOOST_BROKEN_IS_BASE_AND_DERIVED)\r
146       : boost::is_base_and_derived<boost::noncopyable, T>\r
147     #elif !defined(BOOST_NO_IS_ABSTRACT)\r
148       : boost::is_abstract<T>\r
149     #else\r
150       : boost::mpl::false_\r
151     #endif\r
152     {\r
153     };\r
154 \r
155 } // namespace foreach\r
156 \r
157 } // namespace boost\r
158 \r
159 // vc6/7 needs help ordering the following overloads\r
160 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING\r
161 # define BOOST_FOREACH_TAG_DEFAULT ...\r
162 #else\r
163 # define BOOST_FOREACH_TAG_DEFAULT boost::foreach::tag\r
164 #endif\r
165 \r
166 ///////////////////////////////////////////////////////////////////////////////\r
167 // boost_foreach_is_lightweight_proxy\r
168 //   Another customization point for the is_lightweight_proxy optimization,\r
169 //   this one works on legacy compilers. Overload boost_foreach_is_lightweight_proxy\r
170 //   at the global namespace for your type.\r
171 template<typename T>\r
172 inline boost::foreach::is_lightweight_proxy<T> *\r
173 boost_foreach_is_lightweight_proxy(T *&, BOOST_FOREACH_TAG_DEFAULT) { return 0; }\r
174 \r
175 template<typename T>\r
176 inline boost::mpl::true_ *\r
177 boost_foreach_is_lightweight_proxy(std::pair<T, T> *&, boost::foreach::tag) { return 0; }\r
178 \r
179 template<typename T>\r
180 inline boost::mpl::true_ *\r
181 boost_foreach_is_lightweight_proxy(boost::iterator_range<T> *&, boost::foreach::tag) { return 0; }\r
182 \r
183 template<typename T>\r
184 inline boost::mpl::true_ *\r
185 boost_foreach_is_lightweight_proxy(boost::sub_range<T> *&, boost::foreach::tag) { return 0; }\r
186 \r
187 template<typename T>\r
188 inline boost::mpl::true_ *\r
189 boost_foreach_is_lightweight_proxy(T **&, boost::foreach::tag) { return 0; }\r
190 \r
191 ///////////////////////////////////////////////////////////////////////////////\r
192 // boost_foreach_is_noncopyable\r
193 //   Another customization point for the is_noncopyable trait,\r
194 //   this one works on legacy compilers. Overload boost_foreach_is_noncopyable\r
195 //   at the global namespace for your type.\r
196 template<typename T>\r
197 inline boost::foreach::is_noncopyable<T> *\r
198 boost_foreach_is_noncopyable(T *&, BOOST_FOREACH_TAG_DEFAULT) { return 0; }\r
199 \r
200 namespace boost\r
201 {\r
202 \r
203 namespace foreach_detail_\r
204 {\r
205 \r
206 ///////////////////////////////////////////////////////////////////////////////\r
207 // Define some utilities for assessing the properties of expressions\r
208 //\r
209 template<typename Bool1, typename Bool2>\r
210 inline boost::mpl::and_<Bool1, Bool2> *and_(Bool1 *, Bool2 *) { return 0; }\r
211 \r
212 template<typename Bool1, typename Bool2, typename Bool3>\r
213 inline boost::mpl::and_<Bool1, Bool2, Bool3> *and_(Bool1 *, Bool2 *, Bool3 *) { return 0; }\r
214 \r
215 template<typename Bool1, typename Bool2>\r
216 inline boost::mpl::or_<Bool1, Bool2> *or_(Bool1 *, Bool2 *) { return 0; }\r
217 \r
218 template<typename Bool1, typename Bool2, typename Bool3>\r
219 inline boost::mpl::or_<Bool1, Bool2, Bool3> *or_(Bool1 *, Bool2 *, Bool3 *) { return 0; }\r
220 \r
221 template<typename Bool>\r
222 inline boost::mpl::not_<Bool> *not_(Bool *) { return 0; }\r
223 \r
224 template<typename T>\r
225 inline boost::mpl::false_ *is_rvalue_(T &, int) { return 0; }\r
226 \r
227 template<typename T>\r
228 inline boost::mpl::true_ *is_rvalue_(T const &, ...) { return 0; }\r
229 \r
230 template<typename T>\r
231 inline boost::is_array<T> *is_array_(T const &) { return 0; }\r
232 \r
233 template<typename T>\r
234 inline boost::is_const<T> *is_const_(T &) { return 0; }\r
235 \r
236 #ifndef BOOST_FOREACH_NO_RVALUE_DETECTION\r
237 template<typename T>\r
238 inline boost::mpl::true_ *is_const_(T const &) { return 0; }\r
239 #endif\r
240 \r
241 ///////////////////////////////////////////////////////////////////////////////\r
242 // auto_any_t/auto_any\r
243 //  General utility for putting an object of any type into automatic storage\r
244 struct auto_any_base\r
245 {\r
246     // auto_any_base must evaluate to false in boolean context so that\r
247     // they can be declared in if() statements.\r
248     operator bool() const\r
249     {\r
250         return false;\r
251     }\r
252 };\r
253 \r
254 template<typename T>\r
255 struct auto_any : auto_any_base\r
256 {\r
257     auto_any(T const &t)\r
258       : item(t)\r
259     {\r
260     }\r
261 \r
262     // temporaries of type auto_any will be bound to const auto_any_base\r
263     // references, but we still want to be able to mutate the stored\r
264     // data, so declare it as mutable.\r
265     mutable T item;\r
266 };\r
267 \r
268 typedef auto_any_base const &auto_any_t;\r
269 \r
270 template<typename T, typename C>\r
271 inline BOOST_DEDUCED_TYPENAME boost::mpl::if_<C, T const, T>::type &auto_any_cast(auto_any_t a)\r
272 {\r
273     return static_cast<auto_any<T> const &>(a).item;\r
274 }\r
275 \r
276 typedef boost::mpl::true_ const_;\r
277 \r
278 ///////////////////////////////////////////////////////////////////////////////\r
279 // type2type\r
280 //\r
281 template<typename T, typename C = boost::mpl::false_>\r
282 struct type2type\r
283   : boost::mpl::if_<C, T const, T>\r
284 {\r
285 };\r
286 \r
287 template<typename T>\r
288 struct wrap_cstr\r
289 {\r
290     typedef T type;\r
291 };\r
292 \r
293 template<>\r
294 struct wrap_cstr<char *>\r
295 {\r
296     typedef wrap_cstr<char *> type;\r
297     typedef char *iterator;\r
298     typedef char *const_iterator;\r
299 };\r
300 \r
301 template<>\r
302 struct wrap_cstr<char const *>\r
303 {\r
304     typedef wrap_cstr<char const *> type;\r
305     typedef char const *iterator;\r
306     typedef char const *const_iterator;\r
307 };\r
308 \r
309 template<>\r
310 struct wrap_cstr<wchar_t *>\r
311 {\r
312     typedef wrap_cstr<wchar_t *> type;\r
313     typedef wchar_t *iterator;\r
314     typedef wchar_t *const_iterator;\r
315 };\r
316 \r
317 template<>\r
318 struct wrap_cstr<wchar_t const *>\r
319 {\r
320     typedef wrap_cstr<wchar_t const *> type;\r
321     typedef wchar_t const *iterator;\r
322     typedef wchar_t const *const_iterator;\r
323 };\r
324 \r
325 template<typename T>\r
326 struct is_char_array\r
327   : mpl::and_<\r
328         is_array<T>\r
329       , mpl::or_<\r
330             is_convertible<T, char const *>\r
331           , is_convertible<T, wchar_t const *>\r
332         >\r
333     >\r
334 {};\r
335 \r
336 template<typename T, typename C = boost::mpl::false_>\r
337 struct foreach_iterator\r
338 {\r
339     // **** READ THIS IF YOUR COMPILE BREAKS HERE ****\r
340     //\r
341     // There is an ambiguity about how to iterate over arrays of char and wchar_t. \r
342     // Should the last array element be treated as a null terminator to be skipped, or\r
343     // is it just like any other element in the array? To fix the problem, you must\r
344     // say which behavior you want.\r
345     //\r
346     // To treat the container as a null-terminated string, merely cast it to a\r
347     // char const *, as in BOOST_FOREACH( char ch, (char const *)"hello" ) ...\r
348     //\r
349     // To treat the container as an array, use boost::as_array() in <boost/range/as_array.hpp>,\r
350     // as in BOOST_FOREACH( char ch, boost::as_array("hello") ) ...\r
351     #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300\r
352     BOOST_MPL_ASSERT_MSG( (!is_char_array<T>::value), IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING, (T&) );\r
353     #endif\r
354 \r
355     // If the type is a pointer to a null terminated string (as opposed \r
356     // to an array type), there is no ambiguity.\r
357     typedef BOOST_DEDUCED_TYPENAME wrap_cstr<T>::type container;\r
358 \r
359     typedef BOOST_DEDUCED_TYPENAME boost::mpl::eval_if<\r
360         C\r
361       , range_const_iterator<container>\r
362       , range_mutable_iterator<container>\r
363     >::type type;\r
364 };\r
365 \r
366 \r
367 template<typename T, typename C = boost::mpl::false_>\r
368 struct foreach_reverse_iterator\r
369 {\r
370     // **** READ THIS IF YOUR COMPILE BREAKS HERE ****\r
371     //\r
372     // There is an ambiguity about how to iterate over arrays of char and wchar_t. \r
373     // Should the last array element be treated as a null terminator to be skipped, or\r
374     // is it just like any other element in the array? To fix the problem, you must\r
375     // say which behavior you want.\r
376     //\r
377     // To treat the container as a null-terminated string, merely cast it to a\r
378     // char const *, as in BOOST_FOREACH( char ch, (char const *)"hello" ) ...\r
379     //\r
380     // To treat the container as an array, use boost::as_array() in <boost/range/as_array.hpp>,\r
381     // as in BOOST_FOREACH( char ch, boost::as_array("hello") ) ...\r
382     #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300\r
383     BOOST_MPL_ASSERT_MSG( (!is_char_array<T>::value), IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING, (T&) );\r
384     #endif\r
385 \r
386     // If the type is a pointer to a null terminated string (as opposed \r
387     // to an array type), there is no ambiguity.\r
388     typedef BOOST_DEDUCED_TYPENAME wrap_cstr<T>::type container;\r
389 \r
390     typedef BOOST_DEDUCED_TYPENAME boost::mpl::eval_if<\r
391         C\r
392       , range_reverse_iterator<container const>\r
393       , range_reverse_iterator<container>\r
394     >::type type;\r
395 };\r
396 \r
397 template<typename T, typename C = boost::mpl::false_>\r
398 struct foreach_reference\r
399   : iterator_reference<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>\r
400 {\r
401 };\r
402 \r
403 ///////////////////////////////////////////////////////////////////////////////\r
404 // encode_type\r
405 //\r
406 template<typename T>\r
407 inline type2type<T> *encode_type(T &, boost::mpl::false_ *) { return 0; }\r
408 \r
409 template<typename T>\r
410 inline type2type<T, const_> *encode_type(T const &, boost::mpl::true_ *) { return 0; }\r
411 \r
412 ///////////////////////////////////////////////////////////////////////////////\r
413 // set_false\r
414 //\r
415 inline bool set_false(bool &b)\r
416 {\r
417     b = false;\r
418     return false;\r
419 }\r
420 \r
421 ///////////////////////////////////////////////////////////////////////////////\r
422 // to_ptr\r
423 //\r
424 template<typename T>\r
425 inline T *&to_ptr(T const &)\r
426 {\r
427     static T *t = 0;\r
428     return t;\r
429 }\r
430 \r
431 // Borland needs a little extra help with arrays\r
432 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))\r
433 template<typename T,std::size_t N>\r
434 inline T (*&to_ptr(T (&)[N]))[N]\r
435 {\r
436     static T (*t)[N] = 0;\r
437     return t;\r
438 }\r
439 #endif\r
440 \r
441 ///////////////////////////////////////////////////////////////////////////////\r
442 // derefof\r
443 //\r
444 template<typename T>\r
445 inline T &derefof(T *t)\r
446 {\r
447     // This is a work-around for a compiler bug in Borland. If T* is a pointer to array type U(*)[N],\r
448     // then dereferencing it results in a U* instead of U(&)[N]. The cast forces the issue.\r
449     return reinterpret_cast<T &>(\r
450         *const_cast<char *>(\r
451             reinterpret_cast<char const volatile *>(t)\r
452         )\r
453     );\r
454 }\r
455 \r
456 #ifdef BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION\r
457 ///////////////////////////////////////////////////////////////////////////////\r
458 // Detect at compile-time whether an expression yields an rvalue or\r
459 // an lvalue. This is rather non-standard, but some popular compilers\r
460 // accept it.\r
461 ///////////////////////////////////////////////////////////////////////////////\r
462 \r
463 ///////////////////////////////////////////////////////////////////////////////\r
464 // rvalue_probe\r
465 //\r
466 template<typename T>\r
467 struct rvalue_probe\r
468 {\r
469     struct private_type_ {};\r
470     // can't ever return an array by value\r
471     typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<\r
472         boost::mpl::or_<boost::is_abstract<T>, boost::is_array<T> >, private_type_, T\r
473     >::type value_type;\r
474     operator value_type() { return *reinterpret_cast<value_type *>(this); } // never called\r
475     operator T &() const { return *reinterpret_cast<T *>(const_cast<rvalue_probe *>(this)); } // never called\r
476 };\r
477 \r
478 template<typename T>\r
479 rvalue_probe<T> const make_probe(T const &)\r
480 {\r
481     return rvalue_probe<T>();\r
482 }\r
483 \r
484 # define BOOST_FOREACH_IS_RVALUE(COL)                                                           \\r
485     boost::foreach_detail_::and_(                                                               \\r
486         boost::foreach_detail_::not_(boost::foreach_detail_::is_array_(COL))                    \\r
487       , (true ? 0 : boost::foreach_detail_::is_rvalue_(                                         \\r
488             (true ? boost::foreach_detail_::make_probe(COL) : (COL)), 0)))\r
489 \r
490 #elif defined(BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION)\r
491 ///////////////////////////////////////////////////////////////////////////////\r
492 // Detect at run-time whether an expression yields an rvalue\r
493 // or an lvalue. This is 100% standard C++, but not all compilers\r
494 // accept it. Also, it causes FOREACH to break when used with non-\r
495 // copyable collection types.\r
496 ///////////////////////////////////////////////////////////////////////////////\r
497 \r
498 ///////////////////////////////////////////////////////////////////////////////\r
499 // rvalue_probe\r
500 //\r
501 template<typename T>\r
502 struct rvalue_probe\r
503 {\r
504     rvalue_probe(T &t, bool &b)\r
505       : value(t)\r
506       , is_rvalue(b)\r
507     {\r
508     }\r
509 \r
510     struct private_type_ {};\r
511     // can't ever return an array or an abstract type by value\r
512     #ifdef BOOST_NO_IS_ABSTRACT\r
513     typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<\r
514         boost::is_array<T>, private_type_, T\r
515     >::type value_type;\r
516     #else\r
517     typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<\r
518         boost::mpl::or_<boost::is_abstract<T>, boost::is_array<T> >, private_type_, T\r
519     >::type value_type;\r
520     #endif\r
521     \r
522     operator value_type()\r
523     {\r
524         this->is_rvalue = true;\r
525         return this->value;\r
526     }\r
527 \r
528     operator T &() const\r
529     {\r
530         return this->value;\r
531     }\r
532 \r
533 private:\r
534     T &value;\r
535     bool &is_rvalue;\r
536 };\r
537 \r
538 template<typename T>\r
539 rvalue_probe<T> make_probe(T &t, bool &b) { return rvalue_probe<T>(t, b); }\r
540 \r
541 template<typename T>\r
542 rvalue_probe<T const> make_probe(T const &t, bool &b)  { return rvalue_probe<T const>(t, b); }\r
543 \r
544 ///////////////////////////////////////////////////////////////////////////////\r
545 // simple_variant\r
546 //  holds either a T or a T const*\r
547 template<typename T>\r
548 struct simple_variant\r
549 {\r
550     simple_variant(T const *t)\r
551       : is_rvalue(false)\r
552     {\r
553         *static_cast<T const **>(this->data.address()) = t;\r
554     }\r
555 \r
556     simple_variant(T const &t)\r
557       : is_rvalue(true)\r
558     {\r
559         ::new(this->data.address()) T(t);\r
560     }\r
561 \r
562     simple_variant(simple_variant const &that)\r
563       : is_rvalue(that.is_rvalue)\r
564     {\r
565         if(this->is_rvalue)\r
566             ::new(this->data.address()) T(*that.get());\r
567         else\r
568             *static_cast<T const **>(this->data.address()) = that.get();\r
569     }\r
570 \r
571     ~simple_variant()\r
572     {\r
573         if(this->is_rvalue)\r
574             this->get()->~T();\r
575     }\r
576 \r
577     T const *get() const\r
578     {\r
579         if(this->is_rvalue)\r
580             return static_cast<T const *>(this->data.address());\r
581         else\r
582             return *static_cast<T const * const *>(this->data.address());\r
583     }\r
584 \r
585 private:\r
586     enum size_type { size = sizeof(T) > sizeof(T*) ? sizeof(T) : sizeof(T*) };\r
587     simple_variant &operator =(simple_variant const &); \r
588     bool const is_rvalue;\r
589     aligned_storage<size> data;\r
590 };\r
591 \r
592 // If the collection is an array or is noncopyable, it must be an lvalue.\r
593 // If the collection is a lightweight proxy, treat it as an rvalue\r
594 // BUGBUG what about a noncopyable proxy?\r
595 template<typename LValue, typename IsProxy>\r
596 inline BOOST_DEDUCED_TYPENAME boost::enable_if<boost::mpl::or_<LValue, IsProxy>, IsProxy>::type *\r
597 should_copy_impl(LValue *, IsProxy *, bool *)\r
598 {\r
599     return 0;\r
600 }\r
601 \r
602 // Otherwise, we must determine at runtime whether it's an lvalue or rvalue\r
603 inline bool *\r
604 should_copy_impl(boost::mpl::false_ *, boost::mpl::false_ *, bool *is_rvalue)\r
605 {\r
606     return is_rvalue;\r
607 }\r
608 \r
609 #endif\r
610 \r
611 ///////////////////////////////////////////////////////////////////////////////\r
612 // contain\r
613 //\r
614 template<typename T>\r
615 inline auto_any<T> contain(T const &t, boost::mpl::true_ *) // rvalue\r
616 {\r
617     return t;\r
618 }\r
619 \r
620 template<typename T>\r
621 inline auto_any<T *> contain(T &t, boost::mpl::false_ *) // lvalue\r
622 {\r
623     // Cannot seem to get sunpro to handle addressof() with array types.\r
624     #if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x570))\r
625     return &t;\r
626     #else\r
627     return boost::addressof(t);\r
628     #endif\r
629 }\r
630 \r
631 #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION\r
632 template<typename T>\r
633 auto_any<simple_variant<T> >\r
634 contain(T const &t, bool *rvalue)\r
635 {\r
636     return *rvalue ? simple_variant<T>(t) : simple_variant<T>(&t);\r
637 }\r
638 #endif\r
639 \r
640 /////////////////////////////////////////////////////////////////////////////\r
641 // begin\r
642 //\r
643 template<typename T, typename C>\r
644 inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>\r
645 begin(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue\r
646 {\r
647     return boost::begin(auto_any_cast<T, C>(col));\r
648 }\r
649 \r
650 template<typename T, typename C>\r
651 inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>\r
652 begin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue\r
653 {\r
654     typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;\r
655     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iterator;\r
656     return iterator(boost::begin(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));\r
657 }\r
658 \r
659 #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION\r
660 template<typename T>\r
661 auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>\r
662 begin(auto_any_t col, type2type<T, const_> *, bool *)\r
663 {\r
664     return boost::begin(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get());\r
665 }\r
666 #endif\r
667 \r
668 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING\r
669 template<typename T, typename C>\r
670 inline auto_any<T *>\r
671 begin(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *) // null-terminated C-style strings\r
672 {\r
673     return auto_any_cast<T *, boost::mpl::false_>(col);\r
674 }\r
675 #endif\r
676 \r
677 ///////////////////////////////////////////////////////////////////////////////\r
678 // end\r
679 //\r
680 template<typename T, typename C>\r
681 inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>\r
682 end(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue\r
683 {\r
684     return boost::end(auto_any_cast<T, C>(col));\r
685 }\r
686 \r
687 template<typename T, typename C>\r
688 inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>\r
689 end(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue\r
690 {\r
691     typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;\r
692     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iterator;\r
693     return iterator(boost::end(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));\r
694 }\r
695 \r
696 #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION\r
697 template<typename T>\r
698 auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>\r
699 end(auto_any_t col, type2type<T, const_> *, bool *)\r
700 {\r
701     return boost::end(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get());\r
702 }\r
703 #endif\r
704 \r
705 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING\r
706 template<typename T, typename C>\r
707 inline auto_any<int>\r
708 end(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *) // null-terminated C-style strings\r
709 {\r
710     return 0; // not used\r
711 }\r
712 #endif\r
713 \r
714 ///////////////////////////////////////////////////////////////////////////////\r
715 // done\r
716 //\r
717 template<typename T, typename C>\r
718 inline bool done(auto_any_t cur, auto_any_t end, type2type<T, C> *)\r
719 {\r
720     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iter_t;\r
721     return auto_any_cast<iter_t, boost::mpl::false_>(cur) == auto_any_cast<iter_t, boost::mpl::false_>(end);\r
722 }\r
723 \r
724 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING\r
725 template<typename T, typename C>\r
726 inline bool done(auto_any_t cur, auto_any_t, type2type<T *, C> *) // null-terminated C-style strings\r
727 {\r
728     return ! *auto_any_cast<T *, boost::mpl::false_>(cur);\r
729 }\r
730 #endif\r
731 \r
732 ///////////////////////////////////////////////////////////////////////////////\r
733 // next\r
734 //\r
735 template<typename T, typename C>\r
736 inline void next(auto_any_t cur, type2type<T, C> *)\r
737 {\r
738     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iter_t;\r
739     ++auto_any_cast<iter_t, boost::mpl::false_>(cur);\r
740 }\r
741 \r
742 ///////////////////////////////////////////////////////////////////////////////\r
743 // deref\r
744 //\r
745 template<typename T, typename C>\r
746 inline BOOST_DEDUCED_TYPENAME foreach_reference<T, C>::type\r
747 deref(auto_any_t cur, type2type<T, C> *)\r
748 {\r
749     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iter_t;\r
750     return *auto_any_cast<iter_t, boost::mpl::false_>(cur);\r
751 }\r
752 \r
753 /////////////////////////////////////////////////////////////////////////////\r
754 // rbegin\r
755 //\r
756 template<typename T, typename C>\r
757 inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>\r
758 rbegin(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue\r
759 {\r
760     return boost::rbegin(auto_any_cast<T, C>(col));\r
761 }\r
762 \r
763 template<typename T, typename C>\r
764 inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>\r
765 rbegin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue\r
766 {\r
767     typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;\r
768     typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type iterator;\r
769     return iterator(boost::rbegin(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));\r
770 }\r
771 \r
772 #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION\r
773 template<typename T>\r
774 auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type>\r
775 rbegin(auto_any_t col, type2type<T, const_> *, bool *)\r
776 {\r
777     return boost::rbegin(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get());\r
778 }\r
779 #endif\r
780 \r
781 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING\r
782 template<typename T, typename C>\r
783 inline auto_any<reverse_iterator<T *> >\r
784 rbegin(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *) // null-terminated C-style strings\r
785 {\r
786     T *p = auto_any_cast<T *, boost::mpl::false_>(col);\r
787     while(0 != *p)\r
788         ++p;\r
789     return reverse_iterator<T *>(p);\r
790 }\r
791 #endif\r
792 \r
793 ///////////////////////////////////////////////////////////////////////////////\r
794 // rend\r
795 //\r
796 template<typename T, typename C>\r
797 inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>\r
798 rend(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue\r
799 {\r
800     return boost::rend(auto_any_cast<T, C>(col));\r
801 }\r
802 \r
803 template<typename T, typename C>\r
804 inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>\r
805 rend(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue\r
806 {\r
807     typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;\r
808     typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type iterator;\r
809     return iterator(boost::rend(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));\r
810 }\r
811 \r
812 #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION\r
813 template<typename T>\r
814 auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type>\r
815 rend(auto_any_t col, type2type<T, const_> *, bool *)\r
816 {\r
817     return boost::rend(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get());\r
818 }\r
819 #endif\r
820 \r
821 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING\r
822 template<typename T, typename C>\r
823 inline auto_any<reverse_iterator<T *> >\r
824 rend(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *) // null-terminated C-style strings\r
825 {\r
826     return reverse_iterator<T *>(auto_any_cast<T *, boost::mpl::false_>(col));\r
827 }\r
828 #endif\r
829 \r
830 ///////////////////////////////////////////////////////////////////////////////\r
831 // rdone\r
832 //\r
833 template<typename T, typename C>\r
834 inline bool rdone(auto_any_t cur, auto_any_t end, type2type<T, C> *)\r
835 {\r
836     typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type iter_t;\r
837     return auto_any_cast<iter_t, boost::mpl::false_>(cur) == auto_any_cast<iter_t, boost::mpl::false_>(end);\r
838 }\r
839 \r
840 ///////////////////////////////////////////////////////////////////////////////\r
841 // rnext\r
842 //\r
843 template<typename T, typename C>\r
844 inline void rnext(auto_any_t cur, type2type<T, C> *)\r
845 {\r
846     typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type iter_t;\r
847     ++auto_any_cast<iter_t, boost::mpl::false_>(cur);\r
848 }\r
849 \r
850 ///////////////////////////////////////////////////////////////////////////////\r
851 // rderef\r
852 //\r
853 template<typename T, typename C>\r
854 inline BOOST_DEDUCED_TYPENAME foreach_reference<T, C>::type\r
855 rderef(auto_any_t cur, type2type<T, C> *)\r
856 {\r
857     typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type iter_t;\r
858     return *auto_any_cast<iter_t, boost::mpl::false_>(cur);\r
859 }\r
860 \r
861 } // namespace foreach_detail_\r
862 } // namespace boost\r
863 \r
864 // Suppress a bogus code analysis warning on vc8+\r
865 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)\r
866 # define BOOST_FOREACH_SUPPRESS_WARNINGS() __pragma(warning(suppress:6001))\r
867 #else\r
868 # define BOOST_FOREACH_SUPPRESS_WARNINGS()\r
869 #endif\r
870 \r
871 // A sneaky way to get the type of the collection without evaluating the expression\r
872 #define BOOST_FOREACH_TYPEOF(COL)                                                               \\r
873     (true ? 0 : boost::foreach_detail_::encode_type(COL, boost::foreach_detail_::is_const_(COL)))\r
874 \r
875 // returns true_* if the type is noncopyable\r
876 #define BOOST_FOREACH_IS_NONCOPYABLE(COL)                                                       \\r
877     boost_foreach_is_noncopyable(                                                               \\r
878         boost::foreach_detail_::to_ptr(COL)                                                     \\r
879       , boost_foreach_argument_dependent_lookup_hack_value)\r
880 \r
881 // returns true_* if the type is a lightweight proxy (and is not noncopyable)\r
882 #define BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL)                                                 \\r
883     boost::foreach_detail_::and_(                                                               \\r
884         boost::foreach_detail_::not_(BOOST_FOREACH_IS_NONCOPYABLE(COL))                         \\r
885       , boost_foreach_is_lightweight_proxy(                                                     \\r
886             boost::foreach_detail_::to_ptr(COL)                                                 \\r
887           , boost_foreach_argument_dependent_lookup_hack_value))\r
888 \r
889 #ifdef BOOST_FOREACH_COMPILE_TIME_CONST_RVALUE_DETECTION\r
890 ///////////////////////////////////////////////////////////////////////////////\r
891 // R-values and const R-values supported here with zero runtime overhead\r
892 ///////////////////////////////////////////////////////////////////////////////\r
893 \r
894 // No variable is needed to track the rvalue-ness of the collection expression\r
895 # define BOOST_FOREACH_PREAMBLE()                                                               \\r
896     BOOST_FOREACH_SUPPRESS_WARNINGS()\r
897 \r
898 // Evaluate the collection expression\r
899 # define BOOST_FOREACH_EVALUATE(COL)                                                            \\r
900     (COL)\r
901 \r
902 # define BOOST_FOREACH_SHOULD_COPY(COL)                                                         \\r
903     (true ? 0 : boost::foreach_detail_::or_(                                                    \\r
904         BOOST_FOREACH_IS_RVALUE(COL)                                                            \\r
905       , BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL)))\r
906 \r
907 #elif defined(BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION)\r
908 ///////////////////////////////////////////////////////////////////////////////\r
909 // R-values and const R-values supported here\r
910 ///////////////////////////////////////////////////////////////////////////////\r
911 \r
912 // Declare a variable to track the rvalue-ness of the collection expression\r
913 # define BOOST_FOREACH_PREAMBLE()                                                               \\r
914     BOOST_FOREACH_SUPPRESS_WARNINGS()                                                           \\r
915     if (bool _foreach_is_rvalue = false) {} else\r
916 \r
917 // Evaluate the collection expression, and detect if it is an lvalue or and rvalue\r
918 # define BOOST_FOREACH_EVALUATE(COL)                                                            \\r
919     (true ? boost::foreach_detail_::make_probe((COL), _foreach_is_rvalue) : (COL))\r
920 \r
921 // The rvalue/lvalue-ness of the collection expression is determined dynamically, unless\r
922 // type type is an array or is noncopyable or is non-const, in which case we know it's an lvalue.\r
923 // If the type happens to be a lightweight proxy, always make a copy.\r
924 # define BOOST_FOREACH_SHOULD_COPY(COL)                                                         \\r
925     (boost::foreach_detail_::should_copy_impl(                                                  \\r
926         true ? 0 : boost::foreach_detail_::or_(                                                 \\r
927             boost::foreach_detail_::is_array_(COL)                                              \\r
928           , BOOST_FOREACH_IS_NONCOPYABLE(COL)                                                   \\r
929           , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(COL)))               \\r
930       , true ? 0 : BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL)                                      \\r
931       , &_foreach_is_rvalue))\r
932 \r
933 #elif !defined(BOOST_FOREACH_NO_RVALUE_DETECTION)\r
934 ///////////////////////////////////////////////////////////////////////////////\r
935 // R-values supported here, const R-values NOT supported here\r
936 ///////////////////////////////////////////////////////////////////////////////\r
937 \r
938 // No variable is needed to track the rvalue-ness of the collection expression\r
939 # define BOOST_FOREACH_PREAMBLE()                                                               \\r
940     BOOST_FOREACH_SUPPRESS_WARNINGS()\r
941 \r
942 // Evaluate the collection expression\r
943 # define BOOST_FOREACH_EVALUATE(COL)                                                            \\r
944     (COL)\r
945 \r
946 // Determine whether the collection expression is an lvalue or an rvalue.\r
947 // NOTE: this gets the answer wrong for const rvalues.\r
948 # define BOOST_FOREACH_SHOULD_COPY(COL)                                                         \\r
949     (true ? 0 : boost::foreach_detail_::or_(                                                    \\r
950         boost::foreach_detail_::is_rvalue_((COL), 0)                                            \\r
951       , BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL)))\r
952 \r
953 #else\r
954 ///////////////////////////////////////////////////////////////////////////////\r
955 // R-values NOT supported here\r
956 ///////////////////////////////////////////////////////////////////////////////\r
957 \r
958 // No variable is needed to track the rvalue-ness of the collection expression\r
959 # define BOOST_FOREACH_PREAMBLE()                                                               \\r
960     BOOST_FOREACH_SUPPRESS_WARNINGS()\r
961 \r
962 // Evaluate the collection expression\r
963 # define BOOST_FOREACH_EVALUATE(COL)                                                            \\r
964     (COL)\r
965 \r
966 // Can't use rvalues with BOOST_FOREACH (unless they are lightweight proxies)\r
967 # define BOOST_FOREACH_SHOULD_COPY(COL)                                                         \\r
968     (true ? 0 : BOOST_FOREACH_IS_LIGHTWEIGHT_PROXY(COL))\r
969 \r
970 #endif\r
971 \r
972 #define BOOST_FOREACH_CONTAIN(COL)                                                              \\r
973     boost::foreach_detail_::contain(                                                            \\r
974         BOOST_FOREACH_EVALUATE(COL)                                                             \\r
975       , BOOST_FOREACH_SHOULD_COPY(COL))\r
976 \r
977 #define BOOST_FOREACH_BEGIN(COL)                                                                \\r
978     boost::foreach_detail_::begin(                                                              \\r
979         _foreach_col                                                                            \\r
980       , BOOST_FOREACH_TYPEOF(COL)                                                               \\r
981       , BOOST_FOREACH_SHOULD_COPY(COL))\r
982 \r
983 #define BOOST_FOREACH_END(COL)                                                                  \\r
984     boost::foreach_detail_::end(                                                                \\r
985         _foreach_col                                                                            \\r
986       , BOOST_FOREACH_TYPEOF(COL)                                                               \\r
987       , BOOST_FOREACH_SHOULD_COPY(COL))\r
988 \r
989 #define BOOST_FOREACH_DONE(COL)                                                                 \\r
990     boost::foreach_detail_::done(                                                               \\r
991         _foreach_cur                                                                            \\r
992       , _foreach_end                                                                            \\r
993       , BOOST_FOREACH_TYPEOF(COL))\r
994 \r
995 #define BOOST_FOREACH_NEXT(COL)                                                                 \\r
996     boost::foreach_detail_::next(                                                               \\r
997         _foreach_cur                                                                            \\r
998       , BOOST_FOREACH_TYPEOF(COL))\r
999 \r
1000 #define BOOST_FOREACH_DEREF(COL)                                                                \\r
1001     boost::foreach_detail_::deref(                                                              \\r
1002         _foreach_cur                                                                            \\r
1003       , BOOST_FOREACH_TYPEOF(COL))\r
1004 \r
1005 #define BOOST_FOREACH_RBEGIN(COL)                                                               \\r
1006     boost::foreach_detail_::rbegin(                                                             \\r
1007         _foreach_col                                                                            \\r
1008       , BOOST_FOREACH_TYPEOF(COL)                                                               \\r
1009       , BOOST_FOREACH_SHOULD_COPY(COL))\r
1010 \r
1011 #define BOOST_FOREACH_REND(COL)                                                                 \\r
1012     boost::foreach_detail_::rend(                                                               \\r
1013         _foreach_col                                                                            \\r
1014       , BOOST_FOREACH_TYPEOF(COL)                                                               \\r
1015       , BOOST_FOREACH_SHOULD_COPY(COL))\r
1016 \r
1017 #define BOOST_FOREACH_RDONE(COL)                                                                \\r
1018     boost::foreach_detail_::rdone(                                                              \\r
1019         _foreach_cur                                                                            \\r
1020       , _foreach_end                                                                            \\r
1021       , BOOST_FOREACH_TYPEOF(COL))\r
1022 \r
1023 #define BOOST_FOREACH_RNEXT(COL)                                                                \\r
1024     boost::foreach_detail_::rnext(                                                              \\r
1025         _foreach_cur                                                                            \\r
1026       , BOOST_FOREACH_TYPEOF(COL))\r
1027 \r
1028 #define BOOST_FOREACH_RDEREF(COL)                                                               \\r
1029     boost::foreach_detail_::rderef(                                                             \\r
1030         _foreach_cur                                                                            \\r
1031       , BOOST_FOREACH_TYPEOF(COL))\r
1032 \r
1033 ///////////////////////////////////////////////////////////////////////////////\r
1034 // BOOST_FOREACH\r
1035 //\r
1036 //   For iterating over collections. Collections can be\r
1037 //   arrays, null-terminated strings, or STL containers.\r
1038 //   The loop variable can be a value or reference. For\r
1039 //   example:\r
1040 //\r
1041 //   std::list<int> int_list(/*stuff*/);\r
1042 //   BOOST_FOREACH(int &i, int_list)\r
1043 //   {\r
1044 //       /* \r
1045 //        * loop body goes here.\r
1046 //        * i is a reference to the int in int_list.\r
1047 //        */\r
1048 //   }\r
1049 //\r
1050 //   Alternately, you can declare the loop variable first,\r
1051 //   so you can access it after the loop finishes. Obviously,\r
1052 //   if you do it this way, then the loop variable cannot be\r
1053 //   a reference.\r
1054 //\r
1055 //   int i;\r
1056 //   BOOST_FOREACH(i, int_list)\r
1057 //       { ... }\r
1058 //\r
1059 #define BOOST_FOREACH(VAR, COL)                                                                 \\r
1060     BOOST_FOREACH_PREAMBLE()                                                                    \\r
1061     if (boost::foreach_detail_::auto_any_t _foreach_col = BOOST_FOREACH_CONTAIN(COL)) {} else   \\r
1062     if (boost::foreach_detail_::auto_any_t _foreach_cur = BOOST_FOREACH_BEGIN(COL)) {} else     \\r
1063     if (boost::foreach_detail_::auto_any_t _foreach_end = BOOST_FOREACH_END(COL)) {} else       \\r
1064     for (bool _foreach_continue = true;                                                         \\r
1065               _foreach_continue && !BOOST_FOREACH_DONE(COL);                                    \\r
1066               _foreach_continue ? BOOST_FOREACH_NEXT(COL) : (void)0)                            \\r
1067         if  (boost::foreach_detail_::set_false(_foreach_continue)) {} else                      \\r
1068         for (VAR = BOOST_FOREACH_DEREF(COL); !_foreach_continue; _foreach_continue = true)\r
1069 \r
1070 ///////////////////////////////////////////////////////////////////////////////\r
1071 // BOOST_REVERSE_FOREACH\r
1072 //\r
1073 //   For iterating over collections in reverse order. In\r
1074 //   all other respects, BOOST_REVERSE_FOREACH is like\r
1075 //   BOOST_FOREACH.\r
1076 //\r
1077 #define BOOST_REVERSE_FOREACH(VAR, COL)                                                         \\r
1078     BOOST_FOREACH_PREAMBLE()                                                                    \\r
1079     if (boost::foreach_detail_::auto_any_t _foreach_col = BOOST_FOREACH_CONTAIN(COL)) {} else   \\r
1080     if (boost::foreach_detail_::auto_any_t _foreach_cur = BOOST_FOREACH_RBEGIN(COL)) {} else    \\r
1081     if (boost::foreach_detail_::auto_any_t _foreach_end = BOOST_FOREACH_REND(COL)) {} else      \\r
1082     for (bool _foreach_continue = true;                                                         \\r
1083               _foreach_continue && !BOOST_FOREACH_RDONE(COL);                                   \\r
1084               _foreach_continue ? BOOST_FOREACH_RNEXT(COL) : (void)0)                           \\r
1085         if  (boost::foreach_detail_::set_false(_foreach_continue)) {} else                      \\r
1086         for (VAR = BOOST_FOREACH_RDEREF(COL); !_foreach_continue; _foreach_continue = true)\r
1087 \r
1088 #endif\r