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