boost/phoenix/stl/container/container.hpp

   1 /*=============================================================================
   2     Copyright (c) 2004 Angus Leeming
   3     Copyright (c) 2004 Joel de Guzman
   4
   5     Distributed under the Boost Software License, Version 1.0. (See accompanying
   6     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   7 ==============================================================================*/
   8 #ifndef BOOST_PHOENIX_STL_CONTAINER_CONTAINER_HPP
   9 #define BOOST_PHOENIX_STL_CONTAINER_CONTAINER_HPP
  10
  11 #include <boost/phoenix/core/limits.hpp>
  12 #include <boost/mpl/and.hpp>
  13 #include <boost/mpl/not.hpp>
  14 #include <boost/mpl/or.hpp>
  15 #include <boost/mpl/void.hpp>
  16 #include <boost/phoenix/stl/container/detail/container.hpp>
  17 #include <boost/phoenix/function/adapt_callable.hpp>
  18 #include <boost/type_traits/is_const.hpp>
  19
  20 namespace boost { namespace phoenix
  21 {
  22 ///////////////////////////////////////////////////////////////////////////////
  23 //
  24 //  STL container member functions
  25 //
  26 //      Lazy functions for STL container member functions
  27 //
  28 //      These functions provide a mechanism for the lazy evaluation of the
  29 //      public member functions of the STL containers. For an overview of
  30 //      what is meant by 'lazy evaluation', see the comments in operators.hpp
  31 //      and functions.hpp.
  32 //
  33 //      Lazy functions are provided for all of the member functions of the
  34 //      following containers:
  35 //
  36 //      deque - list - map - multimap - vector.
  37 //
  38 //      Indeed, should *your* class have member functions with the same names
  39 //      and signatures as those listed below, then it will automatically be
  40 //      supported. To summarize, lazy functions are provided for member
  41 //      functions:
  42 //
  43 //          assign - at - back - begin - capacity - clear - empty - end -
  44 //          erase - front - get_allocator - insert - key_comp - max_size -
  45 //          pop_back - pop_front - push_back - push_front - rbegin - rend -
  46 //          reserve - resize . size - splice - value_comp.
  47 //
  48 //      The lazy functions' names are the same as the corresponding member
  49 //      function. Sample usage:
  50 //
  51 //      "Normal" version                 "Lazy" version
  52 //      ----------------                 --------------
  53 //      my_vector.at(5)                  phoenix::at(arg1, 5)
  54 //      my_list.size()                   phoenix::size(arg1)
  55 //      my_vector1.swap(my_vector2)      phoenix::swap(arg1, arg2)
  56 //
  57 //      Notice that member functions with names that clash with a
  58 //      function in stl algorithms are absent. This will be provided
  59 //      in Phoenix's algorithm module.
  60 //
  61 //      No support is provided here for lazy versions of operator+=,
  62 //      operator[] etc. Such operators are not specific to STL containers and
  63 //      lazy versions can therefore be found in operators.hpp.
  64 //
  65 ///////////////////////////////////////////////////////////////////////////////
  66
  67 ///////////////////////////////////////////////////////////////////////////////
  68 //
  69 //  Lazy member function implementaions.
  70 //
  71 //      The structs below provide the guts of the implementation. Thereafter,
  72 //      the corresponding lazy function itself is simply:
  73 //
  74 //          function<stl::assign> const assign = stl::assign();
  75 //
  76 //      The structs provide a nested "result" class template whose
  77 //      "type" typedef enables the lazy function to ascertain the type
  78 //      to be returned when it is invoked.
  79 //
  80 //      They also provide operator() member functions with signatures
  81 //      corresponding to those of the underlying member function of
  82 //      the STL container.
  83 //
  84 ///////////////////////////////////////////////////////////////////////////////
  85     namespace stl
  86     {
  87         struct assign
  88         {
  89             template <typename Sig>
  90             struct result;
  91
  92             template <
  93                 typename This
  94               , typename C
  95               , typename Arg1
  96             >
  97             struct result<This(C&, Arg1 const &)>
  98             {
  99                 typedef typename add_reference<C>::type type;
 100             };
 101
 102             template <
 103                 typename This
 104               , typename C
 105               , typename Arg1
 106               , typename Arg2
 107             >
 108             struct result<This(C&, Arg1, Arg2)>
 109             {
 110                 typedef typename add_reference<C>::type type;
 111             };
 112
 113             template <
 114                 typename This
 115               , typename C
 116               , typename Arg1
 117               , typename Arg2
 118               , typename Arg3
 119             >
 120             struct result<This(C&, Arg1, Arg2, Arg3)>
 121             {
 122                 typedef typename add_reference<C>::type type;
 123             };
 124
 125             template <typename C, typename Arg1>
 126             C& operator()(C& c, Arg1 const & arg1) const
 127             {
 128                 c.assign(arg1);
 129                 return c;
 130             }
 131
 132             template <typename C, typename Arg1, typename Arg2>
 133             C& operator()(C& c, Arg1 arg1, Arg2 arg2) const
 134             {
 135                 c.assign(arg1, arg2);
 136                 return c;
 137             }
 138
 139             template <typename C, typename Arg1, typename Arg2, typename Arg3>
 140             C& operator()(
 141                 C& c
 142               , Arg1 arg1
 143               , Arg2 arg2
 144               , Arg3 const & arg3
 145             ) const
 146             {
 147                 return c.assign(arg1, arg2, arg3);
 148             }
 149         };
 150
 151         struct at_impl
 152         {
 153             template <typename Sig>
 154             struct result;
 155
 156             template <typename This, typename C, typename Index>
 157             struct result<This(C&, Index)>
 158             {
 159                 //typedef typename const_qualified_reference_of<C>::type type;
 160                 typedef typename C::value_type & type;
 161             };
 162
 163             template <typename C, typename Index>
 164             typename result<at_impl(C&, Index const&)>::type
 165             operator()(C& c, Index const &i) const
 166             {
 167                 return c.at(i);
 168             }
 169
 170             template <typename This, typename C, typename Index>
 171             struct result<This(C const&, Index)>
 172             {
 173                 typedef typename C::value_type const & type;
 174             };
 175
 176             template <typename C, typename Index>
 177             typename result<at_impl(C const&, Index const&)>::type
 178             operator()(C const& c, Index const &i) const
 179             {
 180                 return c.at(i);
 181             }
 182         };
 183
 184         struct back
 185         {
 186             template <typename Sig>
 187             struct result;
 188
 189             template <typename This, typename C>
 190             struct result<This(C&)>
 191             {
 192                 typedef
 193                     typename const_qualified_reference_of<C>::type
 194                 type;
 195             };
 196
 197             template <typename C>
 198             typename result<back(C&)>::type
 199             operator()(C& c) const
 200             {
 201                 return c.back();
 202             }
 203         };
 204
 205         struct begin
 206         {
 207             template <typename Sig>
 208             struct result;
 209
 210             template <typename This, typename C>
 211             struct result<This(C&)>
 212             {
 213                 typedef typename const_qualified_iterator_of<C>::type type;
 214             };
 215
 216             template <typename C>
 217             typename result<begin(C&)>::type
 218             operator()(C& c) const
 219             {
 220                 return c.begin();
 221             }
 222         };
 223
 224         struct capacity
 225         {
 226             template <typename Sig>
 227             struct result;
 228
 229             template <typename This, typename C>
 230             struct result<This(C&)>
 231             {
 232                 typedef typename size_type_of<C>::type type;
 233             };
 234
 235             template <typename C>
 236             typename result<capacity(C&)>::type
 237             operator()(C const& c) const
 238             {
 239                 return c.capacity();
 240             }
 241         };
 242
 243         struct clear
 244         {
 245             typedef void result_type;
 246
 247             template <typename C>
 248             void operator()(C& c) const
 249             {
 250                 return c.clear();
 251             }
 252         };
 253
 254         struct empty
 255         {
 256             typedef bool result_type;
 257
 258             template <typename C>
 259             bool operator()(C const& c) const
 260             {
 261                 return c.empty();
 262             }
 263         };
 264
 265         struct end
 266         {
 267             template <typename Sig>
 268             struct result;
 269
 270             template <typename This, typename C>
 271             struct result<This(C&)>
 272             {
 273                 typedef typename const_qualified_iterator_of<C>::type type;
 274             };
 275
 276             template <typename C>
 277             typename result<end(C&)>::type
 278             operator()(C& c) const
 279             {
 280                 return c.end();
 281             }
 282         };
 283
 284         namespace result_of
 285         {
 286             template <typename C, typename Arg1, typename Arg2 = mpl::void_>
 287             struct erase
 288             {
 289                 //  BOOST_MSVC #if branch here in map_erase_result non-
 290                 //  standard behavior. The return type should be void but
 291                 //  VC7.1 prefers to return iterator_of<C>. As a result,
 292                 //  VC7.1 complains of error C2562:
 293                 //  boost::phoenix::stl::erase::operator() 'void' function
 294                 //  returning a value. Oh well... :*
 295
 296                 typedef
 297                     boost::mpl::eval_if_c<
 298                         boost::is_same<
 299                             typename remove_reference<Arg1>::type
 300                           , typename iterator_of<C>::type
 301                         >::value
 302 #if defined(BOOST_MSVC)// && (BOOST_MSVC <= 1500)
 303                       , iterator_of<C>
 304 #else
 305                       , boost::mpl::identity<void>
 306 #endif
 307                       , size_type_of<C>
 308                     >
 309                 map_erase_result;
 310
 311                 typedef typename
 312                     boost::mpl::eval_if_c<
 313                         has_mapped_type<C>::value
 314                       , map_erase_result
 315                       , iterator_of<C>
 316                     >::type
 317                 type;
 318             };
 319         }
 320
 321         struct erase
 322         {
 323             //  This mouthful can differentiate between the generic erase
 324             //  functions (Container == std::deque, std::list, std::vector) and
 325             //  that specific to the two map-types, std::map and std::multimap.
 326             //
 327             //  where C is a std::deque, std::list, std::vector:
 328             //
 329             //      1) iterator C::erase(iterator where);
 330             //      2) iterator C::erase(iterator first, iterator last);
 331             //
 332             //  where M is a std::map or std::multimap:
 333             //
 334             //      3) size_type M::erase(const Key& keyval);
 335             //      4) void M::erase(iterator where);
 336             //      5) void M::erase(iterator first, iterator last);
 337
 338             template <typename Sig>
 339             struct result;
 340
 341             template <typename This, typename C, typename Arg1>
 342             struct result<This(C&, Arg1)>
 343                 : result_of::erase<C, Arg1>
 344             {};
 345
 346             template <typename This, typename C, typename Arg1, typename Arg2>
 347             struct result<This(C&, Arg1, Arg2)>
 348                 : result_of::erase<C, Arg1, Arg2>
 349             {};
 350
 351             template <typename C, typename Arg1>
 352             typename stl_impl::disable_if_is_void<
 353                 typename result_of::erase<C, Arg1>::type
 354             >::type
 355             operator()(C& c, Arg1 arg1) const
 356             {
 357                 return c.erase(arg1);
 358             }
 359
 360             template <typename C, typename Arg1>
 361             typename stl_impl::enable_if_is_void<
 362                 typename result_of::erase<C, Arg1>::type
 363             >::type
 364             operator()(C& c, Arg1 arg1) const
 365             {
 366                 c.erase(arg1);
 367             }
 368
 369             template <typename C, typename Arg1, typename Arg2>
 370             typename stl_impl::disable_if_is_void<
 371                 typename result_of::erase<C, Arg1, Arg2>::type
 372             >::type
 373             operator()(C& c, Arg1 arg1, Arg2 arg2) const
 374             {
 375                 return c.erase(arg1, arg2);
 376             }
 377
 378             template <typename C, typename Arg1, typename Arg2>
 379             typename stl_impl::enable_if_is_void<
 380                 typename result_of::erase<C, Arg1, Arg2>::type
 381             >::type
 382             operator()(C& c, Arg1 arg1, Arg2 arg2) const
 383             {
 384                 c.erase(arg1, arg2);
 385             }
 386         };
 387
 388         struct front
 389         {
 390             template <typename Sig>
 391             struct result;
 392
 393             template <typename This, typename C>
 394             struct result<This(C&)>
 395             {
 396                 typedef typename const_qualified_reference_of<C>::type type;
 397             };
 398
 399             template <typename C>
 400             typename result<front(C&)>::type
 401             operator()(C& c) const
 402             {
 403                 return c.front();
 404             }
 405         };
 406
 407         struct get_allocator
 408         {
 409             template <typename Sig>
 410             struct result;
 411
 412             template <typename This, typename C>
 413             struct result<This(C&)>
 414             {
 415                 typedef typename allocator_type_of<C>::type type;
 416             };
 417
 418             template <typename C>
 419             typename result<get_allocator(C const&)>::type
 420             operator()(C& c) const
 421             {
 422                 return c.get_allocator();
 423             }
 424         };
 425
 426         namespace result_of
 427         {
 428             template <
 429                 typename C
 430               , typename Arg1
 431               , typename Arg2 = mpl::void_
 432               , typename Arg3 = mpl::void_
 433             >
 434             class insert
 435             {
 436                 struct pair_iterator_bool
 437                 {
 438                     typedef typename std::pair<typename C::iterator, bool> type;
 439                 };
 440
 441                 typedef
 442                     boost::mpl::eval_if<
 443                         map_insert_returns_pair<typename remove_const<C>::type>
 444                       , pair_iterator_bool
 445                       , iterator_of<C>
 446                     >
 447                 choice_1;
 448
 449                 typedef
 450                     boost::mpl::eval_if_c<
 451                         boost::mpl::and_<
 452                             boost::is_same<Arg3, mpl::void_>
 453                           , boost::mpl::not_<boost::is_same<Arg1, Arg2> >
 454                         >::value
 455                       , iterator_of<C>
 456                       , boost::mpl::identity<void>
 457                     >
 458                 choice_2;
 459
 460             public:
 461
 462                 typedef typename
 463                     boost::mpl::eval_if_c<
 464                         boost::is_same<Arg2, mpl::void_>::value
 465                       , choice_1
 466                       , choice_2
 467                     >::type
 468                 type;
 469             };
 470         }
 471
 472         struct insert
 473         {
 474             //  This mouthful can differentiate between the generic insert
 475             //  functions (Container == deque, list, vector) and those
 476             //  specific to the two map-types, std::map and std::multimap.
 477             //
 478             //  where C is a std::deque, std::list, std::vector:
 479             //
 480             //      1) iterator C::insert(iterator where, value_type value);
 481             //      2) void C::insert(
 482             //          iterator where, size_type count, value_type value);
 483             //      3) template <typename Iter>
 484             //         void C::insert(iterator where, Iter first, Iter last);
 485             //
 486             //  where M is a std::map and MM is a std::multimap:
 487             //
 488             //      4) pair<iterator, bool> M::insert(value_type const&);
 489             //      5) iterator MM::insert(value_type const&);
 490             //
 491             //  where M is a std::map or std::multimap:
 492             //
 493             //      6) template <typename Iter>
 494             //         void M::insert(Iter first, Iter last);
 495
 496             template <typename Sig>
 497             struct result;
 498
 499             template <
 500                 typename This
 501               , typename C
 502               , typename Arg1
 503             >
 504             struct result<This(C &, Arg1)>
 505                 : result_of::insert<C, Arg1>
 506             {};
 507
 508             template <
 509                 typename This
 510               , typename C
 511               , typename Arg1
 512               , typename Arg2
 513             >
 514             struct result<This(C &, Arg1, Arg2)>
 515                 : result_of::insert<C, Arg1, Arg2>
 516             {};
 517
 518             template <
 519                 typename This
 520               , typename C
 521               , typename Arg1
 522               , typename Arg2
 523               , typename Arg3
 524             >
 525             struct result<This(C &, Arg1, Arg2, Arg3)>
 526                 : result_of::insert<C, Arg1, Arg2, Arg3>
 527             {};
 528
 529             template <typename C, typename Arg1>
 530             typename result<insert(C&, Arg1)>::type
 531             operator()(C& c, Arg1 arg1) const
 532             {
 533                 return c.insert(arg1);
 534             }
 535
 536             template <typename C, typename Arg1, typename Arg2>
 537             typename stl_impl::disable_if_is_void<
 538                 typename result<insert(C&, Arg1, Arg2)>::type
 539             >::type
 540             operator()(C& c, Arg1 arg1, Arg2 arg2) const
 541             {
 542                 return c.insert(arg1, arg2);
 543             }
 544
 545             template <typename C, typename Arg1, typename Arg2>
 546             typename stl_impl::enable_if_is_void<
 547                 typename result<insert(C&, Arg1, Arg2)>::type
 548             >::type
 549             operator()(C& c, Arg1 arg1, Arg2 arg2) const
 550             {
 551                 c.insert(arg1, arg2);
 552             }
 553
 554             template <typename C, typename Arg1, typename Arg2, typename Arg3>
 555             typename stl_impl::disable_if_is_void<
 556                 typename result<insert(C&, Arg1, Arg2, Arg3)>::type
 557             >::type
 558             operator()(
 559                 C& c, Arg1 arg1, Arg2 arg2, Arg3 arg3) const
 560             {
 561                 return c.insert(arg1, arg2, arg3);
 562             }
 563
 564             template <typename C, typename Arg1, typename Arg2, typename Arg3>
 565             typename stl_impl::enable_if_is_void<
 566                 typename result<insert(C&, Arg1, Arg2, Arg3)>::type
 567             >::type
 568             operator()(
 569                 C& c, Arg1 arg1, Arg2 arg2, Arg3 arg3) const
 570             {
 571                 c.insert(arg1, arg2, arg3);
 572             }
 573         };
 574
 575         namespace result_of
 576         {
 577             template <typename C>
 578             struct key_comp
 579             {
 580                 typedef typename key_compare_of<C>::type type;
 581             };
 582         }
 583
 584         struct key_comp
 585         {
 586             template <typename Sig>
 587             struct result;
 588
 589             template <typename This, typename C>
 590             struct result<This(C&)>
 591                 : result_of::key_comp<C>
 592             {};
 593
 594             template <typename C>
 595             typename result_of::key_comp<C>::type
 596             operator()(C& c) const
 597             {
 598                 return c.key_comp();
 599             }
 600         };
 601
 602         struct max_size
 603         {
 604             template <typename Sig>
 605             struct result;
 606
 607             template <typename This, typename C>
 608             struct result<This(C&)>
 609             {
 610                 typedef typename size_type_of<C>::type type;
 611             };
 612
 613             template <typename C>
 614             typename result<max_size(C const&)>::type
 615             operator()(C& c) const
 616             {
 617                 return c.max_size();
 618             }
 619         };
 620
 621         struct pop_back
 622         {
 623             typedef void result_type;
 624
 625             template <typename C>
 626             void operator()(C& c) const
 627             {
 628                 return c.pop_back();
 629             }
 630         };
 631
 632         struct pop_front
 633         {
 634             typedef void result_type;
 635
 636             template <typename C>
 637             void operator()(C& c) const
 638             {
 639                 return c.pop_front();
 640             }
 641         };
 642
 643         struct push_back
 644         {
 645             typedef void result_type;
 646
 647             template <typename C, typename Arg>
 648             void operator()(C& c, Arg const& data) const
 649             {
 650                 return c.push_back(data);
 651             }
 652         };
 653
 654         struct push_front
 655         {
 656             typedef void result_type;
 657
 658             template <typename C, typename Arg>
 659             void operator()(C& c, Arg const& data) const
 660             {
 661                 return c.push_front(data);
 662             }
 663         };
 664
 665         struct rbegin
 666         {
 667             template <typename Sig>
 668             struct result;
 669
 670             template <typename This, typename C>
 671             struct result<This(C&)>
 672             {
 673                 typedef typename
 674                     const_qualified_reverse_iterator_of<C>::type
 675                 type;
 676             };
 677
 678             template <typename C>
 679             typename result<rbegin(C&)>::type
 680             operator()(C& c) const
 681             {
 682                 return c.rbegin();
 683             }
 684         };
 685
 686         struct rend
 687         {
 688             template <typename Sig>
 689             struct result;
 690
 691             template <typename This, typename C>
 692             struct result<This(C&)>
 693             {
 694                 typedef typename
 695                     const_qualified_reverse_iterator_of<C>::type
 696                 type;
 697             };
 698
 699             template <typename C>
 700             typename result<rend(C&)>::type
 701             operator()(C& c) const
 702             {
 703                 return c.rend();
 704             }
 705         };
 706
 707         struct reserve
 708         {
 709             typedef void result_type;
 710
 711             template <typename C, typename Arg>
 712             void operator()(C& c, Arg const& count) const
 713             {
 714                 c.reserve(count);
 715             }
 716         };
 717
 718         struct resize
 719         {
 720             typedef void result_type;
 721
 722             template <typename C, typename Arg1>
 723             void operator()(C& c, Arg1 const& arg1) const
 724             {
 725                 c.resize(arg1);
 726             }
 727
 728             template <typename C, typename Arg1, typename Arg2>
 729             void operator()(C& c, Arg1 const& arg1, Arg2 const& arg2) const
 730             {
 731                 c.resize(arg1, arg2);
 732             }
 733         };
 734
 735         struct size
 736         {
 737             template <typename Sig>
 738             struct result;
 739
 740             template <typename This, typename C>
 741             struct result<This(C&)>
 742             {
 743                 typedef typename size_type_of<C>::type type;
 744             };
 745
 746             template <typename C>
 747             typename result<size(C&)>::type
 748             operator()(C& c) const
 749             {
 750                 return c.size();
 751             }
 752         };
 753
 754     struct splice
 755     {
 756         typedef void result_type;
 757
 758         template <typename C, typename Arg1, typename Arg2>
 759         void operator()(C& c, Arg1 arg1, Arg2 &arg2) const
 760         {
 761             c.splice(arg1, arg2);
 762         }
 763
 764         template <
 765             typename C
 766           , typename Arg1
 767           , typename Arg2
 768           , typename Arg3
 769         >
 770         void operator()(
 771             C& c
 772           , Arg1 arg1
 773           , Arg2 & arg2
 774           , Arg3 arg3
 775         ) const
 776         {
 777             c.splice(arg1, arg2, arg3);
 778         }
 779
 780         template <
 781             typename C
 782           , typename Arg1
 783           , typename Arg2
 784           , typename Arg3
 785           , typename Arg4
 786         >
 787         void operator()(
 788             C c
 789           , Arg1 arg1
 790           , Arg2 & arg2
 791           , Arg3 arg3
 792           , Arg4 arg4
 793         ) const
 794         {
 795             c.splice(arg1, arg2, arg3, arg4);
 796         }
 797     };
 798
 799
 800     namespace result_of
 801     {
 802         template <typename C>
 803         struct value_comp
 804         {
 805             typedef typename value_compare_of<C>::type type;
 806         };
 807     }
 808
 809     struct value_comp
 810     {
 811         template <typename Sig>
 812         struct result;
 813
 814         template <typename This, typename C>
 815         struct result<This(C&)>
 816             : result_of::value_comp<C>
 817         {};
 818
 819         template <typename C>
 820         typename result_of::value_comp<C>::type
 821         operator()(C& c) const
 822         {
 823             return c.value_comp();
 824         }
 825     };
 826
 827 } // namespace stl
 828
 829     ///////////////////////////////////////////////////////////////////////////////
 830     //
 831     //  The lazy functions themselves.
 832     //
 833     ///////////////////////////////////////////////////////////////////////////////
 834     namespace adl_barrier
 835     {
 836         BOOST_PHOENIX_ADAPT_CALLABLE(assign, boost::phoenix::stl::assign, 2)
 837         BOOST_PHOENIX_ADAPT_CALLABLE(assign, boost::phoenix::stl::assign, 3)
 838         BOOST_PHOENIX_ADAPT_CALLABLE(assign, boost::phoenix::stl::assign, 4)
 839         BOOST_PHOENIX_ADAPT_CALLABLE(at, ::boost::phoenix::stl::at_impl, 2)
 840         BOOST_PHOENIX_ADAPT_CALLABLE(back, stl::back, 1)
 841         BOOST_PHOENIX_ADAPT_CALLABLE(begin, stl::begin, 1)
 842         BOOST_PHOENIX_ADAPT_CALLABLE(capacity, stl::capacity, 1)
 843         BOOST_PHOENIX_ADAPT_CALLABLE(clear, stl::clear, 1)
 844         BOOST_PHOENIX_ADAPT_CALLABLE(empty, stl::empty, 1)
 845         BOOST_PHOENIX_ADAPT_CALLABLE(end, stl::end, 1)
 846         BOOST_PHOENIX_ADAPT_CALLABLE(erase, stl::erase, 2)
 847         BOOST_PHOENIX_ADAPT_CALLABLE(erase, stl::erase, 3)
 848         BOOST_PHOENIX_ADAPT_CALLABLE(front, stl::front, 1)
 849         BOOST_PHOENIX_ADAPT_CALLABLE(get_allocator, stl::get_allocator, 1)
 850         BOOST_PHOENIX_ADAPT_CALLABLE(insert, stl::insert, 2)
 851         BOOST_PHOENIX_ADAPT_CALLABLE(insert, stl::insert, 3)
 852         BOOST_PHOENIX_ADAPT_CALLABLE(insert, stl::insert, 4)
 853         BOOST_PHOENIX_ADAPT_CALLABLE(key_comp, stl::key_comp, 1)
 854         BOOST_PHOENIX_ADAPT_CALLABLE(max_size, stl::max_size, 1)
 855         BOOST_PHOENIX_ADAPT_CALLABLE(pop_back, stl::pop_back, 1)
 856         BOOST_PHOENIX_ADAPT_CALLABLE(pop_front, stl::pop_front, 1)
 857         BOOST_PHOENIX_ADAPT_CALLABLE(push_back, stl::push_back, 2)
 858         BOOST_PHOENIX_ADAPT_CALLABLE(push_front, stl::push_front, 2)
 859         BOOST_PHOENIX_ADAPT_CALLABLE(rbegin, stl::rbegin, 1)
 860         BOOST_PHOENIX_ADAPT_CALLABLE(rend, stl::rend, 1)
 861         BOOST_PHOENIX_ADAPT_CALLABLE(reserve, stl::reserve, 2)
 862         BOOST_PHOENIX_ADAPT_CALLABLE(resize, stl::resize, 2)
 863         BOOST_PHOENIX_ADAPT_CALLABLE(resize, stl::resize, 3)
 864         BOOST_PHOENIX_ADAPT_CALLABLE(size, stl::size, 1)
 865         BOOST_PHOENIX_ADAPT_CALLABLE(splice, stl::splice, 2)
 866         BOOST_PHOENIX_ADAPT_CALLABLE(splice, stl::splice, 3)
 867         BOOST_PHOENIX_ADAPT_CALLABLE(splice, stl::splice, 4)
 868         BOOST_PHOENIX_ADAPT_CALLABLE(splice, stl::splice, 5)
 869         BOOST_PHOENIX_ADAPT_CALLABLE(value_comp, stl::value_comp, 1)
 870     }
 871
 872     using namespace phoenix::adl_barrier;
 873 }} // namespace boost::phoenix
 874
 875 #endif // BOOST_PHOENIX_STL_CONTAINERS_HPP