boost/functional.hpp

   1 // ------------------------------------------------------------------------------
   2 // Copyright (c) 2000 Cadenza New Zealand Ltd
   3 // Distributed under the Boost Software License, Version 1.0. (See accompany-
   4 // ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5 // ------------------------------------------------------------------------------
   6 // Boost functional.hpp header file
   7 // See http://www.boost.org/libs/functional for documentation.
   8 // ------------------------------------------------------------------------------
   9 // $Id$
  10 // ------------------------------------------------------------------------------
  11
  12 #ifndef BOOST_FUNCTIONAL_HPP
  13 #define BOOST_FUNCTIONAL_HPP
  14
  15 #include <boost/config.hpp>
  16 #include <boost/call_traits.hpp>
  17 #include <functional>
  18
  19 namespace boost
  20 {
  21 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
  22     // --------------------------------------------------------------------------
  23     // The following traits classes allow us to avoid the need for ptr_fun
  24     // because the types of arguments and the result of a function can be
  25     // deduced.
  26     //
  27     // In addition to the standard types defined in unary_function and
  28     // binary_function, we add
  29     //
  30     // - function_type, the type of the function or function object itself.
  31     //
  32     // - param_type, the type that should be used for passing the function or
  33     //   function object as an argument.
  34     // --------------------------------------------------------------------------
  35     namespace detail
  36     {
  37         template <class Operation>
  38         struct unary_traits_imp;
  39
  40         template <class Operation>
  41         struct unary_traits_imp<Operation*>
  42         {
  43             typedef Operation                         function_type;
  44             typedef const function_type &             param_type;
  45             typedef typename Operation::result_type   result_type;
  46             typedef typename Operation::argument_type argument_type;
  47         };
  48
  49         template <class R, class A>
  50         struct unary_traits_imp<R(*)(A)>
  51         {
  52             typedef R (*function_type)(A);
  53             typedef R (*param_type)(A);
  54             typedef R result_type;
  55             typedef A argument_type;
  56         };
  57
  58         template <class Operation>
  59         struct binary_traits_imp;
  60
  61         template <class Operation>
  62         struct binary_traits_imp<Operation*>
  63         {
  64             typedef Operation                                function_type;
  65             typedef const function_type &                    param_type;
  66             typedef typename Operation::result_type          result_type;
  67             typedef typename Operation::first_argument_type  first_argument_type;
  68             typedef typename Operation::second_argument_type second_argument_type;
  69         };
  70
  71         template <class R, class A1, class A2>
  72         struct binary_traits_imp<R(*)(A1,A2)>
  73         {
  74             typedef R (*function_type)(A1,A2);
  75             typedef R (*param_type)(A1,A2);
  76             typedef R result_type;
  77             typedef A1 first_argument_type;
  78             typedef A2 second_argument_type;
  79         };
  80     } // namespace detail
  81
  82     template <class Operation>
  83     struct unary_traits
  84     {
  85         typedef typename detail::unary_traits_imp<Operation*>::function_type function_type;
  86         typedef typename detail::unary_traits_imp<Operation*>::param_type    param_type;
  87         typedef typename detail::unary_traits_imp<Operation*>::result_type   result_type;
  88         typedef typename detail::unary_traits_imp<Operation*>::argument_type argument_type;
  89     };
  90
  91     template <class R, class A>
  92     struct unary_traits<R(*)(A)>
  93     {
  94         typedef R (*function_type)(A);
  95         typedef R (*param_type)(A);
  96         typedef R result_type;
  97         typedef A argument_type;
  98     };
  99
 100     template <class Operation>
 101     struct binary_traits
 102     {
 103         typedef typename detail::binary_traits_imp<Operation*>::function_type        function_type;
 104         typedef typename detail::binary_traits_imp<Operation*>::param_type           param_type;
 105         typedef typename detail::binary_traits_imp<Operation*>::result_type          result_type;
 106         typedef typename detail::binary_traits_imp<Operation*>::first_argument_type  first_argument_type;
 107         typedef typename detail::binary_traits_imp<Operation*>::second_argument_type second_argument_type;
 108     };
 109
 110     template <class R, class A1, class A2>
 111     struct binary_traits<R(*)(A1,A2)>
 112     {
 113         typedef R (*function_type)(A1,A2);
 114         typedef R (*param_type)(A1,A2);
 115         typedef R result_type;
 116         typedef A1 first_argument_type;
 117         typedef A2 second_argument_type;
 118     };
 119 #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 120     // --------------------------------------------------------------------------
 121     // If we have no partial specialisation available, decay to a situation
 122     // that is no worse than in the Standard, i.e., ptr_fun will be required.
 123     // --------------------------------------------------------------------------
 124
 125     template <class Operation>
 126     struct unary_traits
 127     {
 128         typedef Operation                         function_type;
 129         typedef const Operation&                  param_type;
 130         typedef typename Operation::result_type   result_type;
 131         typedef typename Operation::argument_type argument_type;
 132     };
 133
 134     template <class Operation>
 135     struct binary_traits
 136     {
 137         typedef Operation                                function_type;
 138         typedef const Operation &                        param_type;
 139         typedef typename Operation::result_type          result_type;
 140         typedef typename Operation::first_argument_type  first_argument_type;
 141         typedef typename Operation::second_argument_type second_argument_type;
 142     };
 143 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 144
 145     // --------------------------------------------------------------------------
 146     // unary_negate, not1
 147     // --------------------------------------------------------------------------
 148     template <class Predicate>
 149     class unary_negate
 150         : public std::unary_function<typename unary_traits<Predicate>::argument_type,bool>
 151     {
 152       public:
 153         explicit unary_negate(typename unary_traits<Predicate>::param_type x)
 154             :
 155             pred(x)
 156         {}
 157         bool operator()(typename call_traits<typename unary_traits<Predicate>::argument_type>::param_type x) const
 158         {
 159             return !pred(x);
 160         }
 161       private:
 162         typename unary_traits<Predicate>::function_type pred;
 163     };
 164
 165     template <class Predicate>
 166     unary_negate<Predicate> not1(const Predicate &pred)
 167     {
 168         // The cast is to placate Borland C++Builder in certain circumstances.
 169         // I don't think it should be necessary.
 170         return unary_negate<Predicate>((typename unary_traits<Predicate>::param_type)pred);
 171     }
 172
 173     template <class Predicate>
 174     unary_negate<Predicate> not1(Predicate &pred)
 175     {
 176         return unary_negate<Predicate>(pred);
 177     }
 178
 179     // --------------------------------------------------------------------------
 180     // binary_negate, not2
 181     // --------------------------------------------------------------------------
 182     template <class Predicate>
 183     class binary_negate
 184         : public std::binary_function<typename binary_traits<Predicate>::first_argument_type,
 185                                       typename binary_traits<Predicate>::second_argument_type,
 186                                       bool>
 187     {
 188       public:
 189         explicit binary_negate(typename binary_traits<Predicate>::param_type x)
 190             :
 191             pred(x)
 192         {}
 193         bool operator()(typename call_traits<typename binary_traits<Predicate>::first_argument_type>::param_type x,
 194                         typename call_traits<typename binary_traits<Predicate>::second_argument_type>::param_type y) const
 195         {
 196             return !pred(x,y);
 197         }
 198       private:
 199         typename binary_traits<Predicate>::function_type pred;
 200     };
 201
 202     template <class Predicate>
 203     binary_negate<Predicate> not2(const Predicate &pred)
 204     {
 205         // The cast is to placate Borland C++Builder in certain circumstances.
 206         // I don't think it should be necessary.
 207         return binary_negate<Predicate>((typename binary_traits<Predicate>::param_type)pred);
 208     }
 209
 210     template <class Predicate>
 211     binary_negate<Predicate> not2(Predicate &pred)
 212     {
 213         return binary_negate<Predicate>(pred);
 214     }
 215
 216     // --------------------------------------------------------------------------
 217     // binder1st, bind1st
 218     // --------------------------------------------------------------------------
 219     template <class Operation>
 220     class binder1st
 221         : public std::unary_function<typename binary_traits<Operation>::second_argument_type,
 222                                      typename binary_traits<Operation>::result_type>
 223     {
 224       public:
 225         binder1st(typename binary_traits<Operation>::param_type x,
 226                   typename call_traits<typename binary_traits<Operation>::first_argument_type>::param_type y)
 227             :
 228             op(x), value(y)
 229         {}
 230
 231         typename binary_traits<Operation>::result_type
 232         operator()(typename call_traits<typename binary_traits<Operation>::second_argument_type>::param_type x) const
 233         {
 234             return op(value, x);
 235         }
 236
 237       protected:
 238         typename binary_traits<Operation>::function_type op;
 239         typename binary_traits<Operation>::first_argument_type value;
 240     };
 241
 242     template <class Operation>
 243     inline binder1st<Operation> bind1st(const Operation &op,
 244                                         typename call_traits<
 245                                                     typename binary_traits<Operation>::first_argument_type
 246                                         >::param_type x)
 247     {
 248         // The cast is to placate Borland C++Builder in certain circumstances.
 249         // I don't think it should be necessary.
 250         return binder1st<Operation>((typename binary_traits<Operation>::param_type)op, x);
 251     }
 252
 253     template <class Operation>
 254     inline binder1st<Operation> bind1st(Operation &op,
 255                                         typename call_traits<
 256                                                     typename binary_traits<Operation>::first_argument_type
 257                                         >::param_type x)
 258     {
 259         return binder1st<Operation>(op, x);
 260     }
 261
 262     // --------------------------------------------------------------------------
 263     // binder2nd, bind2nd
 264     // --------------------------------------------------------------------------
 265     template <class Operation>
 266     class binder2nd
 267         : public std::unary_function<typename binary_traits<Operation>::first_argument_type,
 268                                      typename binary_traits<Operation>::result_type>
 269     {
 270       public:
 271         binder2nd(typename binary_traits<Operation>::param_type x,
 272                   typename call_traits<typename binary_traits<Operation>::second_argument_type>::param_type y)
 273             :
 274             op(x), value(y)
 275         {}
 276
 277         typename binary_traits<Operation>::result_type
 278         operator()(typename call_traits<typename binary_traits<Operation>::first_argument_type>::param_type x) const
 279         {
 280             return op(x, value);
 281         }
 282
 283       protected:
 284         typename binary_traits<Operation>::function_type op;
 285         typename binary_traits<Operation>::second_argument_type value;
 286     };
 287
 288     template <class Operation>
 289     inline binder2nd<Operation> bind2nd(const Operation &op,
 290                                         typename call_traits<
 291                                                     typename binary_traits<Operation>::second_argument_type
 292                                         >::param_type x)
 293     {
 294         // The cast is to placate Borland C++Builder in certain circumstances.
 295         // I don't think it should be necessary.
 296         return binder2nd<Operation>((typename binary_traits<Operation>::param_type)op, x);
 297     }
 298
 299     template <class Operation>
 300     inline binder2nd<Operation> bind2nd(Operation &op,
 301                                         typename call_traits<
 302                                                     typename binary_traits<Operation>::second_argument_type
 303                                         >::param_type x)
 304     {
 305         return binder2nd<Operation>(op, x);
 306     }
 307
 308     // --------------------------------------------------------------------------
 309     // mem_fun, etc
 310     // --------------------------------------------------------------------------
 311     template <class S, class T>
 312     class mem_fun_t : public std::unary_function<T*, S>
 313     {
 314       public:
 315         explicit mem_fun_t(S (T::*p)())
 316             :
 317             ptr(p)
 318         {}
 319         S operator()(T* p) const
 320         {
 321             return (p->*ptr)();
 322         }
 323       private:
 324         S (T::*ptr)();
 325     };
 326
 327     template <class S, class T, class A>
 328     class mem_fun1_t : public std::binary_function<T*, A, S>
 329     {
 330       public:
 331         explicit mem_fun1_t(S (T::*p)(A))
 332             :
 333             ptr(p)
 334         {}
 335         S operator()(T* p, typename call_traits<A>::param_type x) const
 336         {
 337             return (p->*ptr)(x);
 338         }
 339       private:
 340         S (T::*ptr)(A);
 341     };
 342
 343     template <class S, class T>
 344     class const_mem_fun_t : public std::unary_function<const T*, S>
 345     {
 346       public:
 347         explicit const_mem_fun_t(S (T::*p)() const)
 348             :
 349             ptr(p)
 350         {}
 351         S operator()(const T* p) const
 352         {
 353             return (p->*ptr)();
 354         }
 355       private:
 356         S (T::*ptr)() const;
 357     };
 358
 359     template <class S, class T, class A>
 360     class const_mem_fun1_t : public std::binary_function<const T*, A, S>
 361     {
 362       public:
 363         explicit const_mem_fun1_t(S (T::*p)(A) const)
 364             :
 365             ptr(p)
 366         {}
 367         S operator()(const T* p, typename call_traits<A>::param_type x) const
 368         {
 369             return (p->*ptr)(x);
 370         }
 371       private:
 372         S (T::*ptr)(A) const;
 373     };
 374
 375     template<class S, class T>
 376     inline mem_fun_t<S,T> mem_fun(S (T::*f)())
 377     {
 378         return mem_fun_t<S,T>(f);
 379     }
 380
 381     template<class S, class T, class A>
 382     inline mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A))
 383     {
 384         return mem_fun1_t<S,T,A>(f);
 385     }
 386
 387 #ifndef BOOST_NO_POINTER_TO_MEMBER_CONST
 388     template<class S, class T>
 389     inline const_mem_fun_t<S,T> mem_fun(S (T::*f)() const)
 390     {
 391         return const_mem_fun_t<S,T>(f);
 392     }
 393
 394     template<class S, class T, class A>
 395     inline const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const)
 396     {
 397         return const_mem_fun1_t<S,T,A>(f);
 398     }
 399 #endif // BOOST_NO_POINTER_TO_MEMBER_CONST
 400
 401     // --------------------------------------------------------------------------
 402     // mem_fun_ref, etc
 403     // --------------------------------------------------------------------------
 404     template <class S, class T>
 405     class mem_fun_ref_t : public std::unary_function<T&, S>
 406     {
 407       public:
 408         explicit mem_fun_ref_t(S (T::*p)())
 409             :
 410             ptr(p)
 411         {}
 412         S operator()(T& p) const
 413         {
 414             return (p.*ptr)();
 415         }
 416       private:
 417         S (T::*ptr)();
 418     };
 419
 420     template <class S, class T, class A>
 421     class mem_fun1_ref_t : public std::binary_function<T&, A, S>
 422     {
 423       public:
 424         explicit mem_fun1_ref_t(S (T::*p)(A))
 425             :
 426             ptr(p)
 427         {}
 428         S operator()(T& p, typename call_traits<A>::param_type x) const
 429         {
 430             return (p.*ptr)(x);
 431         }
 432       private:
 433         S (T::*ptr)(A);
 434     };
 435
 436     template <class S, class T>
 437     class const_mem_fun_ref_t : public std::unary_function<const T&, S>
 438     {
 439       public:
 440         explicit const_mem_fun_ref_t(S (T::*p)() const)
 441             :
 442             ptr(p)
 443         {}
 444
 445         S operator()(const T &p) const
 446         {
 447             return (p.*ptr)();
 448         }
 449       private:
 450         S (T::*ptr)() const;
 451     };
 452
 453     template <class S, class T, class A>
 454     class const_mem_fun1_ref_t : public std::binary_function<const T&, A, S>
 455     {
 456       public:
 457         explicit const_mem_fun1_ref_t(S (T::*p)(A) const)
 458             :
 459             ptr(p)
 460         {}
 461
 462         S operator()(const T& p, typename call_traits<A>::param_type x) const
 463         {
 464             return (p.*ptr)(x);
 465         }
 466       private:
 467         S (T::*ptr)(A) const;
 468     };
 469
 470     template<class S, class T>
 471     inline mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)())
 472     {
 473         return mem_fun_ref_t<S,T>(f);
 474     }
 475
 476     template<class S, class T, class A>
 477     inline mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A))
 478     {
 479         return mem_fun1_ref_t<S,T,A>(f);
 480     }
 481
 482 #ifndef BOOST_NO_POINTER_TO_MEMBER_CONST
 483     template<class S, class T>
 484     inline const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const)
 485     {
 486         return const_mem_fun_ref_t<S,T>(f);
 487     }
 488
 489     template<class S, class T, class A>
 490     inline const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const)
 491     {
 492         return const_mem_fun1_ref_t<S,T,A>(f);
 493     }
 494 #endif // BOOST_NO_POINTER_TO_MEMBER_CONST
 495
 496     // --------------------------------------------------------------------------
 497     // ptr_fun
 498     // --------------------------------------------------------------------------
 499     template <class Arg, class Result>
 500     class pointer_to_unary_function : public std::unary_function<Arg,Result>
 501     {
 502       public:
 503         explicit pointer_to_unary_function(Result (*f)(Arg))
 504             :
 505             func(f)
 506         {}
 507
 508         Result operator()(typename call_traits<Arg>::param_type x) const
 509         {
 510             return func(x);
 511         }
 512
 513       private:
 514         Result (*func)(Arg);
 515     };
 516
 517     template <class Arg, class Result>
 518     inline pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg))
 519     {
 520         return pointer_to_unary_function<Arg,Result>(f);
 521     }
 522
 523     template <class Arg1, class Arg2, class Result>
 524     class pointer_to_binary_function : public std::binary_function<Arg1,Arg2,Result>
 525     {
 526       public:
 527         explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2))
 528             :
 529             func(f)
 530         {}
 531
 532         Result operator()(typename call_traits<Arg1>::param_type x, typename call_traits<Arg2>::param_type y) const
 533         {
 534             return func(x,y);
 535         }
 536
 537       private:
 538         Result (*func)(Arg1, Arg2);
 539     };
 540
 541     template <class Arg1, class Arg2, class Result>
 542     inline pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1, Arg2))
 543     {
 544         return pointer_to_binary_function<Arg1,Arg2,Result>(f);
 545     }
 546 } // namespace boost
 547
 548 #endif