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