boost/boost/function.hpp

   1 // Boost.Function library
   2
   3 // Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
   4 //
   5 // Permission to copy, use, sell and distribute this software is granted
   6 // provided this copyright notice appears in all copies.
   7 // Permission to modify the code and to distribute modified code is granted
   8 // provided this copyright notice appears in all copies, and a notice
   9 // that the code was modified is included with the copyright notice.
  10 //
  11 // This software is provided "as is" without express or implied warranty,
  12 // and with no claim as to its suitability for any purpose.
  13
  14 // For more information, see http://www.boost.org
  15
  16 // William Kempf, Jesse Jones and Karl Nelson were all very helpful in the
  17 // design of this library.
  18
  19 #ifndef BOOST_FUNCTION_HPP
  20 #define BOOST_FUNCTION_HPP
  21
  22 #include <boost/function/function_base.hpp>
  23 #include <boost/function/function0.hpp>
  24 #include <boost/function/function1.hpp>
  25 #include <boost/function/function2.hpp>
  26 #include <boost/function/function3.hpp>
  27 #include <boost/function/function4.hpp>
  28 #include <boost/function/function5.hpp>
  29 #include <boost/function/function6.hpp>
  30 #include <boost/function/function7.hpp>
  31 #include <boost/function/function8.hpp>
  32 #include <boost/function/function9.hpp>
  33 #include <boost/function/function10.hpp>
  34
  35 namespace boost {
  36   namespace detail {
  37     namespace function {
  38       // Choose the appropriate underlying implementation
  39       template<int Args> struct real_get_function_impl {};
  40
  41       template<>
  42       struct real_get_function_impl<0>
  43       {
  44         template<
  45           typename R,
  46           typename T1,
  47           typename T2,
  48           typename T3,
  49           typename T4,
  50           typename T5,
  51           typename T6,
  52           typename T7,
  53           typename T8,
  54           typename T9,
  55           typename T10,
  56           typename Policy,
  57           typename Mixin,
  58           typename Allocator
  59         >
  60         struct params
  61         {
  62           typedef function0<R, Policy, Mixin, Allocator> type;
  63         };
  64       };
  65
  66       template<>
  67       struct real_get_function_impl<1>
  68       {
  69         template<
  70           typename R,
  71           typename T1,
  72           typename T2,
  73           typename T3,
  74           typename T4,
  75           typename T5,
  76           typename T6,
  77           typename T7,
  78           typename T8,
  79           typename T9,
  80           typename T10,
  81           typename Policy,
  82           typename Mixin,
  83           typename Allocator
  84         >
  85         struct params
  86         {
  87           typedef function1<R, T1, Policy, Mixin, Allocator> type;
  88         };
  89       };
  90
  91       template<>
  92       struct real_get_function_impl<2>
  93       {
  94         template<
  95           typename R,
  96           typename T1,
  97           typename T2,
  98           typename T3,
  99           typename T4,
 100           typename T5,
 101           typename T6,
 102           typename T7,
 103           typename T8,
 104           typename T9,
 105           typename T10,
 106           typename Policy,
 107           typename Mixin,
 108           typename Allocator
 109         >
 110         struct params
 111         {
 112           typedef function2<R, T1, T2, Policy, Mixin, Allocator> type;
 113         };
 114       };
 115
 116       template<>
 117       struct real_get_function_impl<3>
 118       {
 119         template<
 120           typename R,
 121           typename T1,
 122           typename T2,
 123           typename T3,
 124           typename T4,
 125           typename T5,
 126           typename T6,
 127           typename T7,
 128           typename T8,
 129           typename T9,
 130           typename T10,
 131           typename Policy,
 132           typename Mixin,
 133           typename Allocator
 134         >
 135         struct params
 136         {
 137           typedef function3<R, T1, T2, T3, Policy, Mixin, Allocator> type;
 138         };
 139       };
 140
 141       template<>
 142       struct real_get_function_impl<4>
 143       {
 144         template<
 145           typename R,
 146           typename T1,
 147           typename T2,
 148           typename T3,
 149           typename T4,
 150           typename T5,
 151           typename T6,
 152           typename T7,
 153           typename T8,
 154           typename T9,
 155           typename T10,
 156           typename Policy,
 157           typename Mixin,
 158           typename Allocator
 159         >
 160         struct params
 161         {
 162           typedef function4<R, T1, T2, T3, T4, Policy, Mixin, Allocator> type;
 163         };
 164       };
 165
 166       template<>
 167       struct real_get_function_impl<5>
 168       {
 169         template<
 170           typename R,
 171           typename T1,
 172           typename T2,
 173           typename T3,
 174           typename T4,
 175           typename T5,
 176           typename T6,
 177           typename T7,
 178           typename T8,
 179           typename T9,
 180           typename T10,
 181           typename Policy,
 182           typename Mixin,
 183           typename Allocator
 184         >
 185         struct params
 186         {
 187           typedef function5<R, T1, T2, T3, T4, T5, Policy, Mixin, Allocator>
 188           type;
 189         };
 190       };
 191
 192       template<>
 193       struct real_get_function_impl<6>
 194       {
 195         template<
 196           typename R,
 197           typename T1,
 198           typename T2,
 199           typename T3,
 200           typename T4,
 201           typename T5,
 202           typename T6,
 203           typename T7,
 204           typename T8,
 205           typename T9,
 206           typename T10,
 207           typename Policy,
 208           typename Mixin,
 209           typename Allocator
 210         >
 211         struct params
 212         {
 213           typedef function6<R, T1, T2, T3, T4, T5, T6, Policy, Mixin, Allocator>
 214           type;
 215         };
 216       };
 217
 218       template<>
 219       struct real_get_function_impl<7>
 220       {
 221         template<
 222           typename R,
 223           typename T1,
 224           typename T2,
 225           typename T3,
 226           typename T4,
 227           typename T5,
 228           typename T6,
 229           typename T7,
 230           typename T8,
 231           typename T9,
 232           typename T10,
 233           typename Policy,
 234           typename Mixin,
 235           typename Allocator
 236         >
 237         struct params
 238         {
 239           typedef function7<R, T1, T2, T3, T4, T5, T6, T7, Policy, Mixin,
 240                             Allocator> type;
 241         };
 242       };
 243
 244       template<>
 245       struct real_get_function_impl<8>
 246       {
 247         template<
 248           typename R,
 249           typename T1,
 250           typename T2,
 251           typename T3,
 252           typename T4,
 253           typename T5,
 254           typename T6,
 255           typename T7,
 256           typename T8,
 257           typename T9,
 258           typename T10,
 259           typename Policy,
 260           typename Mixin,
 261           typename Allocator
 262         >
 263         struct params
 264         {
 265           typedef function8<R, T1, T2, T3, T4, T5, T6, T7, T8, Policy, Mixin,
 266                             Allocator> type;
 267         };
 268       };
 269
 270       template<>
 271       struct real_get_function_impl<9>
 272       {
 273         template<
 274           typename R,
 275           typename T1,
 276           typename T2,
 277           typename T3,
 278           typename T4,
 279           typename T5,
 280           typename T6,
 281           typename T7,
 282           typename T8,
 283           typename T9,
 284           typename T10,
 285           typename Policy,
 286           typename Mixin,
 287           typename Allocator
 288         >
 289         struct params
 290         {
 291           typedef function9<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, Policy,
 292                             Mixin, Allocator> type;
 293         };
 294       };
 295
 296       template<>
 297       struct real_get_function_impl<10>
 298       {
 299         template<
 300           typename R,
 301           typename T1,
 302           typename T2,
 303           typename T3,
 304           typename T4,
 305           typename T5,
 306           typename T6,
 307           typename T7,
 308           typename T8,
 309           typename T9,
 310           typename T10,
 311           typename Policy,
 312           typename Mixin,
 313           typename Allocator
 314         >
 315         struct params
 316         {
 317           typedef function10<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
 318                              Policy, Mixin, Allocator> type;
 319         };
 320       };
 321
 322       template<
 323         typename R,
 324         typename T1,
 325         typename T2,
 326         typename T3,
 327         typename T4,
 328         typename T5,
 329         typename T6,
 330         typename T7,
 331         typename T8,
 332         typename T9,
 333         typename T10,
 334         typename Policy = empty_function_policy,
 335         typename Mixin = empty_function_mixin,
 336         typename Allocator = std::allocator<function_base>
 337       >
 338       struct get_function_impl
 339       {
 340         typedef typename real_get_function_impl<
 341           (count_used_args<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value)
 342           >::template params<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
 343                              Policy, Mixin, Allocator>::type
 344         type;
 345       };
 346
 347   template<
 348     typename R,
 349     typename T1,
 350     typename T2,
 351     typename T3,
 352     typename T4,
 353     typename T5,
 354     typename T6,
 355     typename T7,
 356     typename T8,
 357     typename T9,
 358     typename T10,
 359     typename MyPolicy = empty_function_policy,
 360     typename MyMixin = empty_function_mixin,
 361     typename MyAllocator = std::allocator<function_base>
 362   >
 363   struct function_traits_builder
 364   {
 365     typedef typename get_function_impl<R, T1, T2, T3, T4, T5, T6, T7,
 366                                        T8, T9, T10, MyPolicy, MyMixin,
 367                                        MyAllocator>::type
 368       type;
 369
 370     typedef MyPolicy    policy_type;
 371     typedef MyMixin     mixin_type;
 372     typedef MyAllocator allocator_type;
 373
 374 #ifndef BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
 375     template<typename Policy>
 376     struct policy :
 377         public function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
 378                                        T10, Policy, mixin_type,
 379                                        allocator_type> {};
 380
 381     template<typename Mixin>
 382     struct mixin :
 383         public function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
 384                                        T10, policy_type, Mixin,
 385                                        allocator_type> {};
 386
 387     template<typename Allocator>
 388     struct allocator :
 389         public function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
 390                                        T10, policy_type, mixin_type,
 391                                        Allocator> {};
 392 #else
 393     template<typename Policy>
 394     struct policy
 395     {
 396       typedef typename function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7,
 397                                                T8, T9, T10, Policy,
 398                                                mixin_type,
 399                                                allocator_type>::type
 400         type;
 401     };
 402
 403     template<typename Mixin>
 404     struct mixin
 405     {
 406       typedef typename function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7,
 407                                                T8, T9, T10, policy_type, Mixin,
 408                                                allocator_type>::type
 409         type;
 410     };
 411
 412     template<typename Allocator>
 413     struct allocator
 414     {
 415       typedef typename function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7,
 416                                                T8, T9, T10, policy_type,
 417                                                mixin_type, Allocator>::type
 418         type;
 419     };
 420 #endif
 421   };
 422
 423     } // end namespace function
 424   } // end namespace detail
 425
 426   template<
 427     typename R,
 428     typename T1 = detail::function::unusable,
 429     typename T2 = detail::function::unusable,
 430     typename T3 = detail::function::unusable,
 431     typename T4 = detail::function::unusable,
 432     typename T5 = detail::function::unusable,
 433     typename T6 = detail::function::unusable,
 434     typename T7 = detail::function::unusable,
 435     typename T8 = detail::function::unusable,
 436     typename T9 = detail::function::unusable,
 437     typename T10 = detail::function::unusable
 438   >
 439   class function :
 440     public detail::function::get_function_impl<R, T1, T2, T3, T4, T5, T6, T7,
 441                                                T8, T9, T10>::type,
 442     public detail::function::function_traits_builder<R, T1, T2, T3, T4, T5, T6,
 443                                                      T7, T8, T9, T10>
 444   {
 445     typedef typename detail::function::get_function_impl<R, T1, T2, T3, T4, T5,
 446                                                          T6, T7, T8, T9, T10
 447                                                          >::type
 448       base_type;
 449
 450   public:
 451     typedef typename base_type::policy_type policy_type;
 452     typedef typename base_type::mixin_type mixin_type;
 453     typedef typename base_type::allocator_type allocator_type;
 454     typedef function self_type;
 455
 456     function() : base_type() {}
 457
 458     template<typename Functor>
 459     function(Functor BOOST_FUNCTION_TARGET_FIX(const &) f) : base_type(f) {}
 460
 461     function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
 462
 463     template<typename Functor>
 464     self_type& operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
 465     {
 466       self_type(f).swap(*this);
 467       return *this;
 468     }
 469
 470     self_type& operator=(const base_type& f)
 471     {
 472       self_type(f).swap(*this);
 473       return *this;
 474     }
 475
 476     self_type& operator=(const self_type& f)
 477     {
 478       self_type(f).swap(*this);
 479       return *this;
 480     }
 481
 482     template<typename Functor>
 483     void set(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
 484     {
 485       self_type(f).swap(*this);
 486     }
 487
 488     void set(const base_type& f)
 489     {
 490       self_type(f).swap(*this);
 491     }
 492
 493     void set(const self_type& f)
 494     {
 495       self_type(f).swap(*this);
 496     }
 497   };
 498
 499   template<typename R,
 500            typename T1,
 501            typename T2,
 502            typename T3,
 503            typename T4,
 504            typename T5,
 505            typename T6,
 506            typename T7,
 507            typename T8,
 508            typename T9,
 509            typename T10>
 510   inline void swap(function<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& f1,
 511                    function<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& f2)
 512   {
 513     f1.swap(f2);
 514   }
 515 }
 516
 517 #endif