Fixes for VS 2008
[dyninst.git] / external / boost / assign / list_of.hpp
1 // Boost.Assign library\r
2 //\r
3 //  Copyright Thorsten Ottosen 2003-2004. Use, modification and\r
4 //  distribution is subject to the Boost Software License, Version\r
5 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at\r
6 //  http://www.boost.org/LICENSE_1_0.txt)\r
7 //\r
8 // For more information, see http://www.boost.org/libs/assign/\r
9 //\r
10 \r
11 \r
12 #ifndef BOOST_ASSIGN_LIST_OF_HPP\r
13 #define BOOST_ASSIGN_LIST_OF_HPP\r
14 \r
15 #if defined(_MSC_VER) && (_MSC_VER >= 1020)\r
16 # pragma once\r
17 #endif\r
18 \r
19 #include <boost/assign/assignment_exception.hpp>\r
20 #include <boost/range/iterator_range.hpp>\r
21 #include <boost/config.hpp>\r
22 #include <boost/tuple/tuple.hpp>\r
23 #include <boost/type_traits/remove_const.hpp>\r
24 #include <boost/type_traits/remove_reference.hpp>\r
25 #include <boost/type_traits/is_reference.hpp>\r
26 #include <boost/static_assert.hpp>\r
27 #include <boost/type_traits/detail/yes_no_type.hpp>\r
28 #include <boost/type_traits/decay.hpp>\r
29 #include <boost/type_traits/is_array.hpp>\r
30 #include <boost/mpl/if.hpp>\r
31 #include <deque>\r
32 #include <cstddef>\r
33 #include <utility>\r
34 \r
35 #include <boost/preprocessor/repetition/enum_binary_params.hpp>\r
36 #include <boost/preprocessor/repetition/enum_params.hpp>\r
37 #include <boost/preprocessor/iteration/local.hpp>\r
38 \r
39 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))\r
40 // BCB requires full type definition for is_array<> to work correctly.\r
41 #include <boost/array.hpp>\r
42 #endif\r
43 \r
44 namespace boost\r
45 {\r
46 \r
47 // this here is necessary to avoid compiler error in <boost/array.hpp>\r
48 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))\r
49     template< class T, std::size_t sz >\r
50     class array;\r
51 #endif    \r
52     \r
53 namespace assign_detail\r
54 {\r
55     /////////////////////////////////////////////////////////////////////////\r
56     // Part 0: common conversion code\r
57     /////////////////////////////////////////////////////////////////////////\r
58 \r
59     template< class T >\r
60     struct assign_decay\r
61     {\r
62         //\r
63         // Add constness to array parameters\r
64         // to support string literals properly\r
65         //\r
66         typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<\r
67             ::boost::is_array<T>,\r
68             ::boost::decay<const T>,\r
69             ::boost::decay<T> >::type type;\r
70     };\r
71     \r
72     template< class T, std::size_t sz >\r
73     type_traits::yes_type assign_is_array( const array<T,sz>* );\r
74     type_traits::no_type assign_is_array( ... );\r
75     template< class T, class U >\r
76     type_traits::yes_type assign_is_pair( const std::pair<T,U>* );\r
77     type_traits::no_type assign_is_pair( ... ); \r
78 \r
79 \r
80     \r
81     struct array_type_tag\r
82     {\r
83     #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))\r
84     private:\r
85       char dummy_;  // BCB would by default use 8 bytes\r
86     #endif\r
87     };\r
88     struct adapter_type_tag\r
89     {\r
90     #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))\r
91     private:\r
92       char dummy_;  // BCB would by default use 8 bytes\r
93     #endif\r
94     };\r
95     struct pair_type_tag\r
96     {\r
97     #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))\r
98     private:\r
99       char dummy_;  // BCB would by default use 8 bytes\r
100     #endif\r
101     };\r
102     struct default_type_tag\r
103     {\r
104     #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))\r
105     private:\r
106       char dummy_;  // BCB would by default use 8 bytes\r
107     #endif\r
108     };\r
109 \r
110 \r
111     \r
112     template< class DerivedTAssign, class Iterator >\r
113     class converter\r
114     {\r
115     public: // Range operations\r
116         typedef Iterator iterator;\r
117         typedef Iterator const_iterator;\r
118         \r
119         iterator begin() const \r
120         {\r
121             return static_cast<const DerivedTAssign*>(this)->begin();\r
122         }\r
123 \r
124         iterator end() const\r
125         {\r
126             return static_cast<const DerivedTAssign*>(this)->end();\r
127         }\r
128         \r
129     public:\r
130 \r
131         template< class Container >\r
132         Container convert_to_container() const\r
133         {\r
134             static Container* c = 0;\r
135             BOOST_STATIC_CONSTANT( bool, is_array_flag = sizeof( assign_detail::assign_is_array( c ) ) \r
136                                    == sizeof( type_traits::yes_type ) );\r
137 \r
138             typedef BOOST_DEDUCED_TYPENAME mpl::if_c< is_array_flag,\r
139                                                       array_type_tag,\r
140                                              default_type_tag >::type tag_type;\r
141 \r
142             return convert<Container>( c, tag_type() );\r
143         }\r
144         \r
145     private:\r
146         \r
147         template< class Container >\r
148         Container convert( const Container*, default_type_tag ) const\r
149         {\r
150 \r
151 #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)\r
152 // old Dinkumware doesn't support iterator type as template\r
153             Container result;\r
154             iterator it  = begin(), \r
155                      e   = end();\r
156             while( it != e )\r
157             {\r
158                 result.insert( result.end(), *it );\r
159                 ++it;\r
160             }\r
161             return result;\r
162 #else\r
163             return Container( begin(), end() );\r
164 #endif\r
165         }\r
166 \r
167         template< class Array >\r
168         Array convert( const Array*, array_type_tag ) const\r
169         {\r
170             typedef BOOST_DEDUCED_TYPENAME Array::value_type value_type;\r
171 \r
172 #if BOOST_WORKAROUND(BOOST_INTEL, <= 910 ) || BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580 )\r
173             BOOST_DEDUCED_TYPENAME remove_const<Array>::type ar;\r
174 #else\r
175             Array ar;\r
176 #endif            \r
177             const std::size_t sz = ar.size();\r
178             if( sz < static_cast<const DerivedTAssign*>(this)->size() )\r
179                 throw assign::assignment_exception( "array initialized with too many elements" );\r
180             std::size_t n = 0; \r
181             iterator i   = begin(), \r
182                      e   = end();\r
183             for( ; i != e; ++i, ++n )\r
184                 ar[n] = *i;\r
185             for( ; n < sz; ++n )\r
186                 ar[n] = value_type();\r
187             return ar; \r
188         }\r
189 \r
190         template< class Adapter >\r
191         Adapter convert_to_adapter( const Adapter* = 0 ) const\r
192         {\r
193             Adapter a;\r
194             iterator i   = begin(), \r
195                      e   = end();\r
196             for( ; i != e; ++i )\r
197                 a.push( *i );\r
198             return a;\r
199         }\r
200 \r
201     private:\r
202         struct adapter_converter;\r
203         friend struct adapter_converter;\r
204 \r
205         struct adapter_converter\r
206         {\r
207             const converter& gl;\r
208             adapter_converter( const converter& this_ ) : gl( this_ )\r
209             {}\r
210 \r
211             adapter_converter( const adapter_converter& r ) \r
212             : gl( r.gl )\r
213             { }\r
214 \r
215             template< class Adapter >\r
216             operator Adapter() const\r
217             {\r
218                 return gl.convert_to_adapter<Adapter>();\r
219             }\r
220         };\r
221 \r
222     public: \r
223         template< class Container >\r
224         Container to_container( Container& c ) const\r
225         {\r
226             return convert( &c, default_type_tag() ); \r
227         }\r
228 \r
229         adapter_converter to_adapter() const\r
230         {\r
231             return adapter_converter( *this );\r
232         }\r
233 \r
234         template< class Adapter >\r
235         Adapter to_adapter( Adapter& a ) const\r
236         {\r
237             return this->convert_to_adapter( &a ); \r
238         }\r
239 \r
240         template< class Array >\r
241         Array to_array( Array& a ) const\r
242         {\r
243             return convert( &a, array_type_tag() );\r
244         }\r
245     };\r
246 \r
247     template< class T, class I, class Range >\r
248     inline bool operator==( const converter<T,I>& l, const Range& r )\r
249     {\r
250         return ::boost::iterator_range_detail::equal( l, r );\r
251     }\r
252 \r
253     template< class T, class I, class Range >\r
254     inline bool operator==( const Range& l, const converter<T,I>& r )\r
255     {\r
256         return r == l;\r
257     }\r
258 \r
259     template< class T, class I, class Range >\r
260     inline bool operator!=( const converter<T,I>& l, const Range& r )\r
261     {\r
262         return !( l == r );\r
263     }\r
264     \r
265     template< class T, class I, class Range >\r
266     inline bool operator!=( const Range& l, const converter<T,I>& r )\r
267     {\r
268         return !( l == r );\r
269     }\r
270 \r
271     template< class T, class I, class Range >\r
272     inline bool operator<( const converter<T,I>& l, const Range& r )\r
273     {\r
274         return ::boost::iterator_range_detail::less_than( l, r );\r
275     }\r
276 \r
277     template< class T, class I, class Range >\r
278     inline bool operator<( const Range& l, const converter<T,I>& r )\r
279     {\r
280         return ::boost::iterator_range_detail::less_than( l, r );\r
281     }\r
282 \r
283     template< class T, class I, class Range >\r
284     inline bool operator>( const converter<T,I>& l, const Range& r )\r
285     {\r
286         return r < l;\r
287     }\r
288 \r
289     template< class T, class I, class Range >\r
290     inline bool operator>( const Range& l, const converter<T,I>& r )\r
291     {\r
292         return r < l;\r
293     }\r
294 \r
295     template< class T, class I, class Range >\r
296     inline bool operator<=( const converter<T,I>& l, const Range& r )\r
297     {\r
298         return !( l > r );\r
299     }\r
300 \r
301     template< class T, class I, class Range >\r
302     inline bool operator<=( const Range& l, const converter<T,I>& r )\r
303     {\r
304         return !( l > r );\r
305     }\r
306     \r
307     template< class T, class I, class Range >\r
308     inline bool operator>=( const converter<T,I>& l, const Range& r )\r
309     {\r
310         return !( l < r );\r
311     }\r
312 \r
313     template< class T, class I, class Range >\r
314     inline bool operator>=( const Range& l, const converter<T,I>& r )\r
315     {\r
316         return !( l < r );\r
317     }\r
318 \r
319     template< class T, class I, class Elem, class Traits >\r
320     inline std::basic_ostream<Elem,Traits>& \r
321     operator<<( std::basic_ostream<Elem, Traits>& Os,\r
322                 const converter<T,I>& r )\r
323     {\r
324         return Os << ::boost::make_iterator_range( r.begin(), r.end() );\r
325     }\r
326     \r
327     /////////////////////////////////////////////////////////////////////////\r
328     // Part 1: flexible, but inefficient interface\r
329     /////////////////////////////////////////////////////////////////////////    \r
330 \r
331     template< class T > \r
332     class generic_list : \r
333         public converter< generic_list< BOOST_DEDUCED_TYPENAME assign_decay<T>::type >,\r
334                           BOOST_DEDUCED_TYPENAME std::deque<BOOST_DEDUCED_TYPENAME \r
335                                                             assign_decay<T>::type>::iterator >\r
336     {\r
337         typedef BOOST_DEDUCED_TYPENAME assign_decay<T>::type Ty;\r
338         typedef std::deque<Ty>  impl_type;\r
339         mutable impl_type       values_;\r
340         \r
341     public:\r
342         typedef BOOST_DEDUCED_TYPENAME impl_type::iterator         iterator;\r
343         typedef iterator                                           const_iterator;\r
344         typedef BOOST_DEDUCED_TYPENAME impl_type::value_type       value_type;\r
345         typedef BOOST_DEDUCED_TYPENAME impl_type::size_type        size_type;\r
346         typedef BOOST_DEDUCED_TYPENAME impl_type::difference_type  difference_type;\r
347         \r
348     public:\r
349         iterator begin() const       { return values_.begin(); }\r
350         iterator end() const         { return values_.end(); }\r
351         bool empty() const           { return values_.empty(); }\r
352         size_type size() const       { return values_.size(); }\r
353         \r
354     private:\r
355         void push_back( value_type r ) { values_.push_back( r ); }\r
356         \r
357     public:\r
358         generic_list& operator,( const Ty& u )\r
359         {\r
360             this->push_back( u ); \r
361             return *this;\r
362         }\r
363 \r
364         generic_list& operator()()\r
365         {\r
366             this->push_back( Ty() );\r
367             return *this;\r
368         }\r
369 \r
370         generic_list& operator()( const Ty& u )\r
371         {\r
372             this->push_back( u );\r
373             return *this;\r
374         }\r
375         \r
376        \r
377 #ifndef BOOST_ASSIGN_MAX_PARAMS // use user's value\r
378 #define BOOST_ASSIGN_MAX_PARAMS 5\r
379 #endif        \r
380 #define BOOST_ASSIGN_MAX_PARAMETERS (BOOST_ASSIGN_MAX_PARAMS - 1) \r
381 #define BOOST_ASSIGN_PARAMS1(n) BOOST_PP_ENUM_PARAMS(n, class U)\r
382 #define BOOST_ASSIGN_PARAMS2(n) BOOST_PP_ENUM_BINARY_PARAMS(n, U, const& u)\r
383 #define BOOST_ASSIGN_PARAMS3(n) BOOST_PP_ENUM_PARAMS(n, u)\r
384 #define BOOST_ASSIGN_PARAMS4(n) BOOST_PP_ENUM_PARAMS(n, U)\r
385 #define BOOST_ASSIGN_PARAMS2_NO_REF(n) BOOST_PP_ENUM_BINARY_PARAMS(n, U, u)\r
386 \r
387 #define BOOST_PP_LOCAL_LIMITS (1, BOOST_ASSIGN_MAX_PARAMETERS)\r
388 #define BOOST_PP_LOCAL_MACRO(n) \\r
389     template< class U, BOOST_ASSIGN_PARAMS1(n) > \\r
390     generic_list& operator()(U const& u, BOOST_ASSIGN_PARAMS2(n) ) \\r
391     { \\r
392         this->push_back( Ty(u, BOOST_ASSIGN_PARAMS3(n))); \\r
393         return *this; \\r
394     } \\r
395     /**/\r
396         \r
397 #include BOOST_PP_LOCAL_ITERATE()\r
398 \r
399         \r
400         template< class U >\r
401         generic_list& repeat( std::size_t sz, U u )\r
402         {\r
403             std::size_t i = 0;\r
404             while( i++ != sz )\r
405                 this->push_back( u );\r
406             return *this;\r
407         }\r
408         \r
409         template< class Nullary_function >\r
410         generic_list& repeat_fun( std::size_t sz, Nullary_function fun )\r
411         {\r
412             std::size_t i = 0;\r
413             while( i++ != sz )\r
414                 this->push_back( fun() );\r
415             return *this;\r
416         }\r
417 \r
418         template< class SinglePassIterator >\r
419         generic_list& range( SinglePassIterator first, \r
420                              SinglePassIterator last )\r
421         {\r
422             for( ; first != last; ++first )\r
423                 this->push_back( *first );\r
424             return *this;\r
425         }\r
426         \r
427         template< class SinglePassRange >\r
428         generic_list& range( const SinglePassRange& r )\r
429         {\r
430             return range( boost::begin(r), boost::end(r) );\r
431         }\r
432 \r
433         template< class Container >\r
434         operator Container() const\r
435         {\r
436             return this-> BOOST_NESTED_TEMPLATE convert_to_container<Container>();\r
437         }\r
438     };\r
439     \r
440     /////////////////////////////////////////////////////////////////////////\r
441     // Part 2: efficient, but inconvenient interface\r
442     /////////////////////////////////////////////////////////////////////////\r
443 \r
444     template< class T >\r
445     struct assign_reference\r
446     {\r
447         assign_reference()\r
448         { /* intentionally empty */ }\r
449 \r
450         assign_reference( T& r ) : ref_(&r)\r
451         { }\r
452 \r
453         void operator=( T& r )\r
454         {\r
455             ref_ = &r;\r
456         }\r
457 \r
458         operator T&() const\r
459         {\r
460             return *ref_;\r
461         }\r
462 \r
463         void swap( assign_reference& r )\r
464         {\r
465             std::swap( *ref_, *r.ref_ );\r
466         }\r
467 \r
468         T& get_ref() const\r
469         {\r
470             return *ref_;\r
471         }\r
472         \r
473     private:\r
474         T* ref_;\r
475 \r
476     };\r
477 \r
478     template< class T >\r
479     inline bool operator<( const assign_reference<T>& l, \r
480                            const assign_reference<T>& r )\r
481     {\r
482         return l.get_ref() < r.get_ref();\r
483     }\r
484 \r
485     template< class T >\r
486     inline bool operator>( const assign_reference<T>& l,\r
487                            const assign_reference<T>& r )\r
488     {\r
489         return l.get_ref() > r.get_ref();\r
490     }\r
491 \r
492     template< class T >\r
493     inline void swap( assign_reference<T>& l, \r
494                       assign_reference<T>& r )\r
495     {\r
496         l.swap( r );\r
497     }\r
498 \r
499 \r
500     \r
501     template< class T, int N >\r
502     struct static_generic_list : \r
503         public converter< static_generic_list<T,N>, assign_reference<T>* >\r
504     {\r
505     private:\r
506         typedef T                                     internal_value_type;\r
507 \r
508     public:\r
509         typedef assign_reference<internal_value_type> value_type;\r
510         typedef value_type*                           iterator;\r
511         typedef value_type*                           const_iterator;\r
512         typedef std::size_t                           size_type;\r
513         typedef std::ptrdiff_t                        difference_type;\r
514 \r
515     \r
516         static_generic_list( T& r ) :\r
517             current_(1)\r
518         {\r
519             refs_[0] = r;\r
520         }\r
521 \r
522         static_generic_list& operator()( T& r )\r
523         {\r
524             insert( r );\r
525             return *this;\r
526         }\r
527 \r
528         iterator begin() const \r
529         {\r
530             return &refs_[0];\r
531         }\r
532 \r
533         iterator end() const\r
534         {\r
535             return &refs_[current_];\r
536         }\r
537 \r
538         size_type size() const\r
539         {\r
540             return static_cast<size_type>( current_ ); \r
541         }\r
542 \r
543         bool empty() const\r
544         {\r
545             return false;\r
546         }\r
547 \r
548         template< class ForwardIterator >\r
549         static_generic_list& range( ForwardIterator first, \r
550                                     ForwardIterator last )\r
551         {\r
552             for( ; first != last; ++first )\r
553                 this->insert( *first );\r
554             return *this;\r
555         }\r
556 \r
557         template< class ForwardRange >\r
558         static_generic_list& range( ForwardRange& r )\r
559         {\r
560             return range( boost::begin(r), boost::end(r) );\r
561         }\r
562 \r
563         template< class ForwardRange >\r
564         static_generic_list& range( const ForwardRange& r )\r
565         {\r
566             return range( boost::begin(r), boost::end(r) );\r
567         }\r
568 \r
569         template< class Container >\r
570         operator Container() const\r
571         {\r
572             return this-> BOOST_NESTED_TEMPLATE convert_to_container<Container>();\r
573         }\r
574 \r
575     private:\r
576         void insert( T& r )\r
577         {\r
578             refs_[current_] = r;\r
579             ++current_;\r
580         }\r
581         \r
582         static_generic_list();\r
583         \r
584         mutable assign_reference<internal_value_type> refs_[N];\r
585         int current_;\r
586     };\r
587 \r
588 } // namespace 'assign_detail'\r
589 \r
590 namespace assign\r
591 {\r
592     template< class T >\r
593     inline assign_detail::generic_list<T>\r
594     list_of()\r
595     {\r
596         return assign_detail::generic_list<T>()( T() );\r
597     }\r
598     \r
599     template< class T >\r
600     inline assign_detail::generic_list<T> \r
601     list_of( const T& t )\r
602     {\r
603         return assign_detail::generic_list<T>()( t );\r
604     }\r
605 \r
606     template< int N, class T >\r
607     inline assign_detail::static_generic_list< BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<T>::type,N>\r
608     ref_list_of( T& t )\r
609     {\r
610         return assign_detail::static_generic_list<BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<T>::type,N>( t );\r
611     }\r
612     \r
613     template< int N, class T >\r
614     inline assign_detail::static_generic_list<const BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<T>::type,N>\r
615     cref_list_of( const T& t )\r
616     {\r
617         return assign_detail::static_generic_list<const BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<T>::type,N>( t );\r
618     }\r
619 \r
620 #define BOOST_PP_LOCAL_LIMITS (1, BOOST_ASSIGN_MAX_PARAMETERS)\r
621 #define BOOST_PP_LOCAL_MACRO(n) \\r
622     template< class T, class U, BOOST_ASSIGN_PARAMS1(n) > \\r
623     inline assign_detail::generic_list<T> \\r
624     list_of(U const& u, BOOST_ASSIGN_PARAMS2(n) ) \\r
625     { \\r
626         return assign_detail::generic_list<T>()(u, BOOST_ASSIGN_PARAMS3(n)); \\r
627     } \\r
628     /**/\r
629     \r
630 #include BOOST_PP_LOCAL_ITERATE()\r
631 \r
632 #define BOOST_PP_LOCAL_LIMITS (1, BOOST_ASSIGN_MAX_PARAMETERS)\r
633 #define BOOST_PP_LOCAL_MACRO(n) \\r
634     template< class U, BOOST_ASSIGN_PARAMS1(n) > \\r
635     inline assign_detail::generic_list< tuple<U, BOOST_ASSIGN_PARAMS4(n)> > \\r
636     tuple_list_of(U u, BOOST_ASSIGN_PARAMS2_NO_REF(n) ) \\r
637     { \\r
638         return assign_detail::generic_list< tuple<U, BOOST_ASSIGN_PARAMS4(n)> >()( tuple<U,BOOST_ASSIGN_PARAMS4(n)>( u, BOOST_ASSIGN_PARAMS3(n) )); \\r
639     } \\r
640     /**/\r
641     \r
642 #include BOOST_PP_LOCAL_ITERATE()\r
643 \r
644 \r
645     template< class Key, class T >\r
646     inline assign_detail::generic_list< std::pair\r
647         < \r
648             BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<Key>::type, \r
649             BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<T>::type\r
650         > >\r
651     map_list_of( const Key& k, const T& t )\r
652     {\r
653         typedef BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<Key>::type k_type;\r
654         typedef BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<T>::type   t_type;\r
655         return assign_detail::generic_list< std::pair<k_type,t_type> >()( k, t );\r
656     }\r
657 \r
658     template< class F, class S >\r
659     inline assign_detail::generic_list< std::pair\r
660         < \r
661             BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<F>::type, \r
662             BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<S>::type\r
663         > >\r
664     pair_list_of( const F& f, const S& s )\r
665     {\r
666         return map_list_of( f, s );\r
667     }\r
668 \r
669 \r
670 } // namespace 'assign'\r
671 } // namespace 'boost'\r
672 \r
673 \r
674 #undef BOOST_ASSIGN_PARAMS1\r
675 #undef BOOST_ASSIGN_PARAMS2\r
676 #undef BOOST_ASSIGN_PARAMS3\r
677 #undef BOOST_ASSIGN_PARAMS4\r
678 #undef BOOST_ASSIGN_PARAMS2_NO_REF\r
679 #undef BOOST_ASSIGN_MAX_PARAMETERS\r
680 \r
681 #endif\r