Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. // Functor implementations -*- C++ -*-
  2.  
  3. // Copyright (C) 2001-2015 Free Software Foundation, Inc.
  4. //
  5. // This file is part of the GNU ISO C++ Library.  This library is free
  6. // software; you can redistribute it and/or modify it under the
  7. // terms of the GNU General Public License as published by the
  8. // Free Software Foundation; either version 3, or (at your option)
  9. // any later version.
  10.  
  11. // This library is distributed in the hope that it will be useful,
  12. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. // GNU General Public License for more details.
  15.  
  16. // Under Section 7 of GPL version 3, you are granted additional
  17. // permissions described in the GCC Runtime Library Exception, version
  18. // 3.1, as published by the Free Software Foundation.
  19.  
  20. // You should have received a copy of the GNU General Public License and
  21. // a copy of the GCC Runtime Library Exception along with this program;
  22. // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23. // <http://www.gnu.org/licenses/>.
  24.  
  25. /*
  26.  *
  27.  * Copyright (c) 1994
  28.  * Hewlett-Packard Company
  29.  *
  30.  * Permission to use, copy, modify, distribute and sell this software
  31.  * and its documentation for any purpose is hereby granted without fee,
  32.  * provided that the above copyright notice appear in all copies and
  33.  * that both that copyright notice and this permission notice appear
  34.  * in supporting documentation.  Hewlett-Packard Company makes no
  35.  * representations about the suitability of this software for any
  36.  * purpose.  It is provided "as is" without express or implied warranty.
  37.  *
  38.  *
  39.  * Copyright (c) 1996-1998
  40.  * Silicon Graphics Computer Systems, Inc.
  41.  *
  42.  * Permission to use, copy, modify, distribute and sell this software
  43.  * and its documentation for any purpose is hereby granted without fee,
  44.  * provided that the above copyright notice appear in all copies and
  45.  * that both that copyright notice and this permission notice appear
  46.  * in supporting documentation.  Silicon Graphics makes no
  47.  * representations about the suitability of this software for any
  48.  * purpose.  It is provided "as is" without express or implied warranty.
  49.  */
  50.  
  51. /** @file bits/stl_function.h
  52.  *  This is an internal header file, included by other library headers.
  53.  *  Do not attempt to use it directly. @headername{functional}
  54.  */
  55.  
  56. #ifndef _STL_FUNCTION_H
  57. #define _STL_FUNCTION_H 1
  58.  
  59. #if __cplusplus > 201103L
  60. #include <bits/move.h>
  61. #endif
  62.  
  63. namespace std _GLIBCXX_VISIBILITY(default)
  64. {
  65. _GLIBCXX_BEGIN_NAMESPACE_VERSION
  66.  
  67.   // 20.3.1 base classes
  68.   /** @defgroup functors Function Objects
  69.    * @ingroup utilities
  70.    *
  71.    *  Function objects, or @e functors, are objects with an @c operator()
  72.    *  defined and accessible.  They can be passed as arguments to algorithm
  73.    *  templates and used in place of a function pointer.  Not only is the
  74.    *  resulting expressiveness of the library increased, but the generated
  75.    *  code can be more efficient than what you might write by hand.  When we
  76.    *  refer to @a functors, then, generally we include function pointers in
  77.    *  the description as well.
  78.    *
  79.    *  Often, functors are only created as temporaries passed to algorithm
  80.    *  calls, rather than being created as named variables.
  81.    *
  82.    *  Two examples taken from the standard itself follow.  To perform a
  83.    *  by-element addition of two vectors @c a and @c b containing @c double,
  84.    *  and put the result in @c a, use
  85.    *  \code
  86.    *  transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>());
  87.    *  \endcode
  88.    *  To negate every element in @c a, use
  89.    *  \code
  90.    *  transform(a.begin(), a.end(), a.begin(), negate<double>());
  91.    *  \endcode
  92.    *  The addition and negation functions will be inlined directly.
  93.    *
  94.    *  The standard functors are derived from structs named @c unary_function
  95.    *  and @c binary_function.  These two classes contain nothing but typedefs,
  96.    *  to aid in generic (template) programming.  If you write your own
  97.    *  functors, you might consider doing the same.
  98.    *
  99.    *  @{
  100.    */
  101.   /**
  102.    *  This is one of the @link functors functor base classes@endlink.
  103.    */
  104.   template<typename _Arg, typename _Result>
  105.     struct unary_function
  106.     {
  107.       /// @c argument_type is the type of the argument
  108.       typedef _Arg      argument_type;  
  109.  
  110.       /// @c result_type is the return type
  111.       typedef _Result   result_type;  
  112.     };
  113.  
  114.   /**
  115.    *  This is one of the @link functors functor base classes@endlink.
  116.    */
  117.   template<typename _Arg1, typename _Arg2, typename _Result>
  118.     struct binary_function
  119.     {
  120.       /// @c first_argument_type is the type of the first argument
  121.       typedef _Arg1     first_argument_type;
  122.  
  123.       /// @c second_argument_type is the type of the second argument
  124.       typedef _Arg2     second_argument_type;
  125.  
  126.       /// @c result_type is the return type
  127.       typedef _Result   result_type;
  128.     };
  129.   /** @}  */
  130.  
  131.   // 20.3.2 arithmetic
  132.   /** @defgroup arithmetic_functors Arithmetic Classes
  133.    * @ingroup functors
  134.    *
  135.    *  Because basic math often needs to be done during an algorithm,
  136.    *  the library provides functors for those operations.  See the
  137.    *  documentation for @link functors the base classes@endlink
  138.    *  for examples of their use.
  139.    *
  140.    *  @{
  141.    */
  142.  
  143. #if __cplusplus > 201103L
  144.   struct __is_transparent;  // undefined
  145.  
  146.   template<typename _Tp = void>
  147.     struct plus;
  148.  
  149.   template<typename _Tp = void>
  150.     struct minus;
  151.  
  152.   template<typename _Tp = void>
  153.     struct multiplies;
  154.  
  155.   template<typename _Tp = void>
  156.     struct divides;
  157.  
  158.   template<typename _Tp = void>
  159.     struct modulus;
  160.  
  161.   template<typename _Tp = void>
  162.     struct negate;
  163. #endif
  164.  
  165.   /// One of the @link arithmetic_functors math functors@endlink.
  166.   template<typename _Tp>
  167.     struct plus : public binary_function<_Tp, _Tp, _Tp>
  168.     {
  169.       _GLIBCXX14_CONSTEXPR
  170.       _Tp
  171.       operator()(const _Tp& __x, const _Tp& __y) const
  172.       { return __x + __y; }
  173.     };
  174.  
  175.   /// One of the @link arithmetic_functors math functors@endlink.
  176.   template<typename _Tp>
  177.     struct minus : public binary_function<_Tp, _Tp, _Tp>
  178.     {
  179.       _GLIBCXX14_CONSTEXPR
  180.       _Tp
  181.       operator()(const _Tp& __x, const _Tp& __y) const
  182.       { return __x - __y; }
  183.     };
  184.  
  185.   /// One of the @link arithmetic_functors math functors@endlink.
  186.   template<typename _Tp>
  187.     struct multiplies : public binary_function<_Tp, _Tp, _Tp>
  188.     {
  189.       _GLIBCXX14_CONSTEXPR
  190.       _Tp
  191.       operator()(const _Tp& __x, const _Tp& __y) const
  192.       { return __x * __y; }
  193.     };
  194.  
  195.   /// One of the @link arithmetic_functors math functors@endlink.
  196.   template<typename _Tp>
  197.     struct divides : public binary_function<_Tp, _Tp, _Tp>
  198.     {
  199.       _GLIBCXX14_CONSTEXPR
  200.       _Tp
  201.       operator()(const _Tp& __x, const _Tp& __y) const
  202.       { return __x / __y; }
  203.     };
  204.  
  205.   /// One of the @link arithmetic_functors math functors@endlink.
  206.   template<typename _Tp>
  207.     struct modulus : public binary_function<_Tp, _Tp, _Tp>
  208.     {
  209.       _GLIBCXX14_CONSTEXPR
  210.       _Tp
  211.       operator()(const _Tp& __x, const _Tp& __y) const
  212.       { return __x % __y; }
  213.     };
  214.  
  215.   /// One of the @link arithmetic_functors math functors@endlink.
  216.   template<typename _Tp>
  217.     struct negate : public unary_function<_Tp, _Tp>
  218.     {
  219.       _GLIBCXX14_CONSTEXPR
  220.       _Tp
  221.       operator()(const _Tp& __x) const
  222.       { return -__x; }
  223.     };
  224.  
  225. #if __cplusplus > 201103L
  226.  
  227. #define __cpp_lib_transparent_operators 201210
  228. //#define __cpp_lib_generic_associative_lookup 201304
  229.  
  230.   template<>
  231.     struct plus<void>
  232.     {
  233.       template <typename _Tp, typename _Up>
  234.         _GLIBCXX14_CONSTEXPR
  235.         auto
  236.         operator()(_Tp&& __t, _Up&& __u) const
  237.         noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
  238.         -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
  239.         { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }
  240.  
  241.       typedef __is_transparent is_transparent;
  242.     };
  243.  
  244.   /// One of the @link arithmetic_functors math functors@endlink.
  245.   template<>
  246.     struct minus<void>
  247.     {
  248.       template <typename _Tp, typename _Up>
  249.         _GLIBCXX14_CONSTEXPR
  250.         auto
  251.         operator()(_Tp&& __t, _Up&& __u) const
  252.         noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
  253.         -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
  254.         { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }
  255.  
  256.       typedef __is_transparent is_transparent;
  257.     };
  258.  
  259.   /// One of the @link arithmetic_functors math functors@endlink.
  260.   template<>
  261.     struct multiplies<void>
  262.     {
  263.       template <typename _Tp, typename _Up>
  264.         _GLIBCXX14_CONSTEXPR
  265.         auto
  266.         operator()(_Tp&& __t, _Up&& __u) const
  267.         noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
  268.         -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
  269.         { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }
  270.  
  271.       typedef __is_transparent is_transparent;
  272.     };
  273.  
  274.   /// One of the @link arithmetic_functors math functors@endlink.
  275.   template<>
  276.     struct divides<void>
  277.     {
  278.       template <typename _Tp, typename _Up>
  279.         _GLIBCXX14_CONSTEXPR
  280.         auto
  281.         operator()(_Tp&& __t, _Up&& __u) const
  282.         noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
  283.         -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
  284.         { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }
  285.  
  286.       typedef __is_transparent is_transparent;
  287.     };
  288.  
  289.   /// One of the @link arithmetic_functors math functors@endlink.
  290.   template<>
  291.     struct modulus<void>
  292.     {
  293.       template <typename _Tp, typename _Up>
  294.         _GLIBCXX14_CONSTEXPR
  295.         auto
  296.         operator()(_Tp&& __t, _Up&& __u) const
  297.         noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
  298.         -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
  299.         { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }
  300.  
  301.       typedef __is_transparent is_transparent;
  302.     };
  303.  
  304.   /// One of the @link arithmetic_functors math functors@endlink.
  305.   template<>
  306.     struct negate<void>
  307.     {
  308.       template <typename _Tp>
  309.         _GLIBCXX14_CONSTEXPR
  310.         auto
  311.         operator()(_Tp&& __t) const
  312.         noexcept(noexcept(-std::forward<_Tp>(__t)))
  313.         -> decltype(-std::forward<_Tp>(__t))
  314.         { return -std::forward<_Tp>(__t); }
  315.  
  316.       typedef __is_transparent is_transparent;
  317.     };
  318. #endif
  319.   /** @}  */
  320.  
  321.   // 20.3.3 comparisons
  322.   /** @defgroup comparison_functors Comparison Classes
  323.    * @ingroup functors
  324.    *
  325.    *  The library provides six wrapper functors for all the basic comparisons
  326.    *  in C++, like @c <.
  327.    *
  328.    *  @{
  329.    */
  330. #if __cplusplus > 201103L
  331.   template<typename _Tp = void>
  332.     struct equal_to;
  333.  
  334.   template<typename _Tp = void>
  335.     struct not_equal_to;
  336.  
  337.   template<typename _Tp = void>
  338.     struct greater;
  339.  
  340.   template<typename _Tp = void>
  341.     struct less;
  342.  
  343.   template<typename _Tp = void>
  344.     struct greater_equal;
  345.  
  346.   template<typename _Tp = void>
  347.     struct less_equal;
  348. #endif
  349.  
  350.   /// One of the @link comparison_functors comparison functors@endlink.
  351.   template<typename _Tp>
  352.     struct equal_to : public binary_function<_Tp, _Tp, bool>
  353.     {
  354.       _GLIBCXX14_CONSTEXPR
  355.       bool
  356.       operator()(const _Tp& __x, const _Tp& __y) const
  357.       { return __x == __y; }
  358.     };
  359.  
  360.   /// One of the @link comparison_functors comparison functors@endlink.
  361.   template<typename _Tp>
  362.     struct not_equal_to : public binary_function<_Tp, _Tp, bool>
  363.     {
  364.       _GLIBCXX14_CONSTEXPR
  365.       bool
  366.       operator()(const _Tp& __x, const _Tp& __y) const
  367.       { return __x != __y; }
  368.     };
  369.  
  370.   /// One of the @link comparison_functors comparison functors@endlink.
  371.   template<typename _Tp>
  372.     struct greater : public binary_function<_Tp, _Tp, bool>
  373.     {
  374.       _GLIBCXX14_CONSTEXPR
  375.       bool
  376.       operator()(const _Tp& __x, const _Tp& __y) const
  377.       { return __x > __y; }
  378.     };
  379.  
  380.   /// One of the @link comparison_functors comparison functors@endlink.
  381.   template<typename _Tp>
  382.     struct less : public binary_function<_Tp, _Tp, bool>
  383.     {
  384.       _GLIBCXX14_CONSTEXPR
  385.       bool
  386.       operator()(const _Tp& __x, const _Tp& __y) const
  387.       { return __x < __y; }
  388.     };
  389.  
  390.   /// One of the @link comparison_functors comparison functors@endlink.
  391.   template<typename _Tp>
  392.     struct greater_equal : public binary_function<_Tp, _Tp, bool>
  393.     {
  394.       _GLIBCXX14_CONSTEXPR
  395.       bool
  396.       operator()(const _Tp& __x, const _Tp& __y) const
  397.       { return __x >= __y; }
  398.     };
  399.  
  400.   /// One of the @link comparison_functors comparison functors@endlink.
  401.   template<typename _Tp>
  402.     struct less_equal : public binary_function<_Tp, _Tp, bool>
  403.     {
  404.       _GLIBCXX14_CONSTEXPR
  405.       bool
  406.       operator()(const _Tp& __x, const _Tp& __y) const
  407.       { return __x <= __y; }
  408.     };
  409.  
  410. #if __cplusplus > 201103L
  411.   /// One of the @link comparison_functors comparison functors@endlink.
  412.   template<>
  413.     struct equal_to<void>
  414.     {
  415.       template <typename _Tp, typename _Up>
  416.         _GLIBCXX14_CONSTEXPR
  417.         auto
  418.         operator()(_Tp&& __t, _Up&& __u) const
  419.         noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
  420.         -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
  421.         { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }
  422.  
  423.       typedef __is_transparent is_transparent;
  424.     };
  425.  
  426.   /// One of the @link comparison_functors comparison functors@endlink.
  427.   template<>
  428.     struct not_equal_to<void>
  429.     {
  430.       template <typename _Tp, typename _Up>
  431.         _GLIBCXX14_CONSTEXPR
  432.         auto
  433.         operator()(_Tp&& __t, _Up&& __u) const
  434.         noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
  435.         -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
  436.         { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }
  437.  
  438.       typedef __is_transparent is_transparent;
  439.     };
  440.  
  441.   /// One of the @link comparison_functors comparison functors@endlink.
  442.   template<>
  443.     struct greater<void>
  444.     {
  445.       template <typename _Tp, typename _Up>
  446.         _GLIBCXX14_CONSTEXPR
  447.         auto
  448.         operator()(_Tp&& __t, _Up&& __u) const
  449.         noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
  450.         -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
  451.         { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
  452.  
  453.       typedef __is_transparent is_transparent;
  454.     };
  455.  
  456.   /// One of the @link comparison_functors comparison functors@endlink.
  457.   template<>
  458.     struct less<void>
  459.     {
  460.       template <typename _Tp, typename _Up>
  461.         _GLIBCXX14_CONSTEXPR
  462.         auto
  463.         operator()(_Tp&& __t, _Up&& __u) const
  464.         noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
  465.         -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
  466.         { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
  467.  
  468.       typedef __is_transparent is_transparent;
  469.     };
  470.  
  471.   /// One of the @link comparison_functors comparison functors@endlink.
  472.   template<>
  473.     struct greater_equal<void>
  474.     {
  475.       template <typename _Tp, typename _Up>
  476.         _GLIBCXX14_CONSTEXPR
  477.         auto
  478.         operator()(_Tp&& __t, _Up&& __u) const
  479.         noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
  480.         -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
  481.         { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
  482.  
  483.       typedef __is_transparent is_transparent;
  484.     };
  485.  
  486.   /// One of the @link comparison_functors comparison functors@endlink.
  487.   template<>
  488.     struct less_equal<void>
  489.     {
  490.       template <typename _Tp, typename _Up>
  491.         _GLIBCXX14_CONSTEXPR
  492.         auto
  493.         operator()(_Tp&& __t, _Up&& __u) const
  494.         noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
  495.         -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
  496.         { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
  497.  
  498.       typedef __is_transparent is_transparent;
  499.     };
  500. #endif
  501.   /** @}  */
  502.  
  503.   // 20.3.4 logical operations
  504.   /** @defgroup logical_functors Boolean Operations Classes
  505.    * @ingroup functors
  506.    *
  507.    *  Here are wrapper functors for Boolean operations: @c &&, @c ||,
  508.    *  and @c !.
  509.    *
  510.    *  @{
  511.    */
  512. #if __cplusplus > 201103L
  513.   template<typename _Tp = void>
  514.     struct logical_and;
  515.  
  516.   template<typename _Tp = void>
  517.     struct logical_or;
  518.  
  519.   template<typename _Tp = void>
  520.     struct logical_not;
  521. #endif
  522.  
  523.   /// One of the @link logical_functors Boolean operations functors@endlink.
  524.   template<typename _Tp>
  525.     struct logical_and : public binary_function<_Tp, _Tp, bool>
  526.     {
  527.       _GLIBCXX14_CONSTEXPR
  528.       bool
  529.       operator()(const _Tp& __x, const _Tp& __y) const
  530.       { return __x && __y; }
  531.     };
  532.  
  533.   /// One of the @link logical_functors Boolean operations functors@endlink.
  534.   template<typename _Tp>
  535.     struct logical_or : public binary_function<_Tp, _Tp, bool>
  536.     {
  537.       _GLIBCXX14_CONSTEXPR
  538.       bool
  539.       operator()(const _Tp& __x, const _Tp& __y) const
  540.       { return __x || __y; }
  541.     };
  542.  
  543.   /// One of the @link logical_functors Boolean operations functors@endlink.
  544.   template<typename _Tp>
  545.     struct logical_not : public unary_function<_Tp, bool>
  546.     {
  547.       _GLIBCXX14_CONSTEXPR
  548.       bool
  549.       operator()(const _Tp& __x) const
  550.       { return !__x; }
  551.     };
  552.  
  553. #if __cplusplus > 201103L
  554.   /// One of the @link logical_functors Boolean operations functors@endlink.
  555.   template<>
  556.     struct logical_and<void>
  557.     {
  558.       template <typename _Tp, typename _Up>
  559.         _GLIBCXX14_CONSTEXPR
  560.         auto
  561.         operator()(_Tp&& __t, _Up&& __u) const
  562.         noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
  563.         -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
  564.         { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }
  565.  
  566.       typedef __is_transparent is_transparent;
  567.     };
  568.  
  569.   /// One of the @link logical_functors Boolean operations functors@endlink.
  570.   template<>
  571.     struct logical_or<void>
  572.     {
  573.       template <typename _Tp, typename _Up>
  574.         _GLIBCXX14_CONSTEXPR
  575.         auto
  576.         operator()(_Tp&& __t, _Up&& __u) const
  577.         noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
  578.         -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
  579.         { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }
  580.  
  581.       typedef __is_transparent is_transparent;
  582.     };
  583.  
  584.   /// One of the @link logical_functors Boolean operations functors@endlink.
  585.   template<>
  586.     struct logical_not<void>
  587.     {
  588.       template <typename _Tp>
  589.         _GLIBCXX14_CONSTEXPR
  590.         auto
  591.         operator()(_Tp&& __t) const
  592.         noexcept(noexcept(!std::forward<_Tp>(__t)))
  593.         -> decltype(!std::forward<_Tp>(__t))
  594.         { return !std::forward<_Tp>(__t); }
  595.  
  596.       typedef __is_transparent is_transparent;
  597.     };
  598. #endif
  599.   /** @}  */
  600.  
  601. #if __cplusplus > 201103L
  602.   template<typename _Tp = void>
  603.     struct bit_and;
  604.  
  605.   template<typename _Tp = void>
  606.     struct bit_or;
  607.  
  608.   template<typename _Tp = void>
  609.     struct bit_xor;
  610.  
  611.   template<typename _Tp = void>
  612.     struct bit_not;
  613. #endif
  614.  
  615.   // _GLIBCXX_RESOLVE_LIB_DEFECTS
  616.   // DR 660. Missing Bitwise Operations.
  617.   template<typename _Tp>
  618.     struct bit_and : public binary_function<_Tp, _Tp, _Tp>
  619.     {
  620.       _GLIBCXX14_CONSTEXPR
  621.       _Tp
  622.       operator()(const _Tp& __x, const _Tp& __y) const
  623.       { return __x & __y; }
  624.     };
  625.  
  626.   template<typename _Tp>
  627.     struct bit_or : public binary_function<_Tp, _Tp, _Tp>
  628.     {
  629.       _GLIBCXX14_CONSTEXPR
  630.       _Tp
  631.       operator()(const _Tp& __x, const _Tp& __y) const
  632.       { return __x | __y; }
  633.     };
  634.  
  635.   template<typename _Tp>
  636.     struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
  637.     {
  638.       _GLIBCXX14_CONSTEXPR
  639.       _Tp
  640.       operator()(const _Tp& __x, const _Tp& __y) const
  641.       { return __x ^ __y; }
  642.     };
  643.  
  644.   template<typename _Tp>
  645.     struct bit_not : public unary_function<_Tp, _Tp>
  646.     {
  647.     _GLIBCXX14_CONSTEXPR
  648.       _Tp
  649.       operator()(const _Tp& __x) const
  650.       { return ~__x; }
  651.     };
  652.  
  653. #if __cplusplus > 201103L
  654.   template <>
  655.     struct bit_and<void>
  656.     {
  657.       template <typename _Tp, typename _Up>
  658.         _GLIBCXX14_CONSTEXPR
  659.         auto
  660.         operator()(_Tp&& __t, _Up&& __u) const
  661.         noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
  662.         -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
  663.         { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }
  664.  
  665.       typedef __is_transparent is_transparent;
  666.     };
  667.  
  668.   template <>
  669.     struct bit_or<void>
  670.     {
  671.       template <typename _Tp, typename _Up>
  672.         _GLIBCXX14_CONSTEXPR
  673.         auto
  674.         operator()(_Tp&& __t, _Up&& __u) const
  675.         noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
  676.         -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
  677.         { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }
  678.  
  679.       typedef __is_transparent is_transparent;
  680.     };
  681.  
  682.   template <>
  683.     struct bit_xor<void>
  684.     {
  685.       template <typename _Tp, typename _Up>
  686.         _GLIBCXX14_CONSTEXPR
  687.         auto
  688.         operator()(_Tp&& __t, _Up&& __u) const
  689.         noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
  690.         -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
  691.         { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }
  692.  
  693.       typedef __is_transparent is_transparent;
  694.     };
  695.  
  696.   template <>
  697.     struct bit_not<void>
  698.     {
  699.       template <typename _Tp>
  700.         _GLIBCXX14_CONSTEXPR
  701.         auto
  702.         operator()(_Tp&& __t) const
  703.         noexcept(noexcept(~std::forward<_Tp>(__t)))
  704.         -> decltype(~std::forward<_Tp>(__t))
  705.         { return ~std::forward<_Tp>(__t); }
  706.  
  707.       typedef __is_transparent is_transparent;
  708.     };
  709. #endif
  710.  
  711.   // 20.3.5 negators
  712.   /** @defgroup negators Negators
  713.    * @ingroup functors
  714.    *
  715.    *  The functions @c not1 and @c not2 each take a predicate functor
  716.    *  and return an instance of @c unary_negate or
  717.    *  @c binary_negate, respectively.  These classes are functors whose
  718.    *  @c operator() performs the stored predicate function and then returns
  719.    *  the negation of the result.
  720.    *
  721.    *  For example, given a vector of integers and a trivial predicate,
  722.    *  \code
  723.    *  struct IntGreaterThanThree
  724.    *    : public std::unary_function<int, bool>
  725.    *  {
  726.    *      bool operator() (int x) { return x > 3; }
  727.    *  };
  728.    *
  729.    *  std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
  730.    *  \endcode
  731.    *  The call to @c find_if will locate the first index (i) of @c v for which
  732.    *  <code>!(v[i] > 3)</code> is true.
  733.    *
  734.    *  The not1/unary_negate combination works on predicates taking a single
  735.    *  argument.  The not2/binary_negate combination works on predicates which
  736.    *  take two arguments.
  737.    *
  738.    *  @{
  739.    */
  740.   /// One of the @link negators negation functors@endlink.
  741.   template<typename _Predicate>
  742.     class unary_negate
  743.     : public unary_function<typename _Predicate::argument_type, bool>
  744.     {
  745.     protected:
  746.       _Predicate _M_pred;
  747.  
  748.     public:
  749.       _GLIBCXX14_CONSTEXPR
  750.       explicit
  751.       unary_negate(const _Predicate& __x) : _M_pred(__x) { }
  752.  
  753.       _GLIBCXX14_CONSTEXPR
  754.       bool
  755.       operator()(const typename _Predicate::argument_type& __x) const
  756.       { return !_M_pred(__x); }
  757.     };
  758.  
  759.   /// One of the @link negators negation functors@endlink.
  760.   template<typename _Predicate>
  761.     _GLIBCXX14_CONSTEXPR
  762.     inline unary_negate<_Predicate>
  763.     not1(const _Predicate& __pred)
  764.     { return unary_negate<_Predicate>(__pred); }
  765.  
  766.   /// One of the @link negators negation functors@endlink.
  767.   template<typename _Predicate>
  768.     class binary_negate
  769.     : public binary_function<typename _Predicate::first_argument_type,
  770.                              typename _Predicate::second_argument_type, bool>
  771.     {
  772.     protected:
  773.       _Predicate _M_pred;
  774.  
  775.     public:
  776.       _GLIBCXX14_CONSTEXPR
  777.       explicit
  778.       binary_negate(const _Predicate& __x) : _M_pred(__x) { }
  779.  
  780.       _GLIBCXX14_CONSTEXPR
  781.       bool
  782.       operator()(const typename _Predicate::first_argument_type& __x,
  783.                  const typename _Predicate::second_argument_type& __y) const
  784.       { return !_M_pred(__x, __y); }
  785.     };
  786.  
  787.   /// One of the @link negators negation functors@endlink.
  788.   template<typename _Predicate>
  789.     _GLIBCXX14_CONSTEXPR
  790.     inline binary_negate<_Predicate>
  791.     not2(const _Predicate& __pred)
  792.     { return binary_negate<_Predicate>(__pred); }
  793.   /** @}  */
  794.  
  795.   // 20.3.7 adaptors pointers functions
  796.   /** @defgroup pointer_adaptors Adaptors for pointers to functions
  797.    * @ingroup functors
  798.    *
  799.    *  The advantage of function objects over pointers to functions is that
  800.    *  the objects in the standard library declare nested typedefs describing
  801.    *  their argument and result types with uniform names (e.g., @c result_type
  802.    *  from the base classes @c unary_function and @c binary_function).
  803.    *  Sometimes those typedefs are required, not just optional.
  804.    *
  805.    *  Adaptors are provided to turn pointers to unary (single-argument) and
  806.    *  binary (double-argument) functions into function objects.  The
  807.    *  long-winded functor @c pointer_to_unary_function is constructed with a
  808.    *  function pointer @c f, and its @c operator() called with argument @c x
  809.    *  returns @c f(x).  The functor @c pointer_to_binary_function does the same
  810.    *  thing, but with a double-argument @c f and @c operator().
  811.    *
  812.    *  The function @c ptr_fun takes a pointer-to-function @c f and constructs
  813.    *  an instance of the appropriate functor.
  814.    *
  815.    *  @{
  816.    */
  817.   /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
  818.   template<typename _Arg, typename _Result>
  819.     class pointer_to_unary_function : public unary_function<_Arg, _Result>
  820.     {
  821.     protected:
  822.       _Result (*_M_ptr)(_Arg);
  823.  
  824.     public:
  825.       pointer_to_unary_function() { }
  826.  
  827.       explicit
  828.       pointer_to_unary_function(_Result (*__x)(_Arg))
  829.       : _M_ptr(__x) { }
  830.  
  831.       _Result
  832.       operator()(_Arg __x) const
  833.       { return _M_ptr(__x); }
  834.     };
  835.  
  836.   /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
  837.   template<typename _Arg, typename _Result>
  838.     inline pointer_to_unary_function<_Arg, _Result>
  839.     ptr_fun(_Result (*__x)(_Arg))
  840.     { return pointer_to_unary_function<_Arg, _Result>(__x); }
  841.  
  842.   /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
  843.   template<typename _Arg1, typename _Arg2, typename _Result>
  844.     class pointer_to_binary_function
  845.     : public binary_function<_Arg1, _Arg2, _Result>
  846.     {
  847.     protected:
  848.       _Result (*_M_ptr)(_Arg1, _Arg2);
  849.  
  850.     public:
  851.       pointer_to_binary_function() { }
  852.  
  853.       explicit
  854.       pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
  855.       : _M_ptr(__x) { }
  856.  
  857.       _Result
  858.       operator()(_Arg1 __x, _Arg2 __y) const
  859.       { return _M_ptr(__x, __y); }
  860.     };
  861.  
  862.   /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
  863.   template<typename _Arg1, typename _Arg2, typename _Result>
  864.     inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
  865.     ptr_fun(_Result (*__x)(_Arg1, _Arg2))
  866.     { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
  867.   /** @}  */
  868.  
  869.   template<typename _Tp>
  870.     struct _Identity
  871.     : public unary_function<_Tp,_Tp>
  872.     {
  873.       _Tp&
  874.       operator()(_Tp& __x) const
  875.       { return __x; }
  876.  
  877.       const _Tp&
  878.       operator()(const _Tp& __x) const
  879.       { return __x; }
  880.     };
  881.  
  882.   template<typename _Pair>
  883.     struct _Select1st
  884.     : public unary_function<_Pair, typename _Pair::first_type>
  885.     {
  886.       typename _Pair::first_type&
  887.       operator()(_Pair& __x) const
  888.       { return __x.first; }
  889.  
  890.       const typename _Pair::first_type&
  891.       operator()(const _Pair& __x) const
  892.       { return __x.first; }
  893.  
  894. #if __cplusplus >= 201103L
  895.       template<typename _Pair2>
  896.         typename _Pair2::first_type&
  897.         operator()(_Pair2& __x) const
  898.         { return __x.first; }
  899.  
  900.       template<typename _Pair2>
  901.         const typename _Pair2::first_type&
  902.         operator()(const _Pair2& __x) const
  903.         { return __x.first; }
  904. #endif
  905.     };
  906.  
  907.   template<typename _Pair>
  908.     struct _Select2nd
  909.     : public unary_function<_Pair, typename _Pair::second_type>
  910.     {
  911.       typename _Pair::second_type&
  912.       operator()(_Pair& __x) const
  913.       { return __x.second; }
  914.  
  915.       const typename _Pair::second_type&
  916.       operator()(const _Pair& __x) const
  917.       { return __x.second; }
  918.     };
  919.  
  920.   // 20.3.8 adaptors pointers members
  921.   /** @defgroup memory_adaptors Adaptors for pointers to members
  922.    * @ingroup functors
  923.    *
  924.    *  There are a total of 8 = 2^3 function objects in this family.
  925.    *   (1) Member functions taking no arguments vs member functions taking
  926.    *        one argument.
  927.    *   (2) Call through pointer vs call through reference.
  928.    *   (3) Const vs non-const member function.
  929.    *
  930.    *  All of this complexity is in the function objects themselves.  You can
  931.    *   ignore it by using the helper function mem_fun and mem_fun_ref,
  932.    *   which create whichever type of adaptor is appropriate.
  933.    *
  934.    *  @{
  935.    */
  936.   /// One of the @link memory_adaptors adaptors for member
  937.   /// pointers@endlink.
  938.   template<typename _Ret, typename _Tp>
  939.     class mem_fun_t : public unary_function<_Tp*, _Ret>
  940.     {
  941.     public:
  942.       explicit
  943.       mem_fun_t(_Ret (_Tp::*__pf)())
  944.       : _M_f(__pf) { }
  945.  
  946.       _Ret
  947.       operator()(_Tp* __p) const
  948.       { return (__p->*_M_f)(); }
  949.  
  950.     private:
  951.       _Ret (_Tp::*_M_f)();
  952.     };
  953.  
  954.   /// One of the @link memory_adaptors adaptors for member
  955.   /// pointers@endlink.
  956.   template<typename _Ret, typename _Tp>
  957.     class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
  958.     {
  959.     public:
  960.       explicit
  961.       const_mem_fun_t(_Ret (_Tp::*__pf)() const)
  962.       : _M_f(__pf) { }
  963.  
  964.       _Ret
  965.       operator()(const _Tp* __p) const
  966.       { return (__p->*_M_f)(); }
  967.  
  968.     private:
  969.       _Ret (_Tp::*_M_f)() const;
  970.     };
  971.  
  972.   /// One of the @link memory_adaptors adaptors for member
  973.   /// pointers@endlink.
  974.   template<typename _Ret, typename _Tp>
  975.     class mem_fun_ref_t : public unary_function<_Tp, _Ret>
  976.     {
  977.     public:
  978.       explicit
  979.       mem_fun_ref_t(_Ret (_Tp::*__pf)())
  980.       : _M_f(__pf) { }
  981.  
  982.       _Ret
  983.       operator()(_Tp& __r) const
  984.       { return (__r.*_M_f)(); }
  985.  
  986.     private:
  987.       _Ret (_Tp::*_M_f)();
  988.   };
  989.  
  990.   /// One of the @link memory_adaptors adaptors for member
  991.   /// pointers@endlink.
  992.   template<typename _Ret, typename _Tp>
  993.     class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
  994.     {
  995.     public:
  996.       explicit
  997.       const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
  998.       : _M_f(__pf) { }
  999.  
  1000.       _Ret
  1001.       operator()(const _Tp& __r) const
  1002.       { return (__r.*_M_f)(); }
  1003.  
  1004.     private:
  1005.       _Ret (_Tp::*_M_f)() const;
  1006.     };
  1007.  
  1008.   /// One of the @link memory_adaptors adaptors for member
  1009.   /// pointers@endlink.
  1010.   template<typename _Ret, typename _Tp, typename _Arg>
  1011.     class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
  1012.     {
  1013.     public:
  1014.       explicit
  1015.       mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
  1016.       : _M_f(__pf) { }
  1017.  
  1018.       _Ret
  1019.       operator()(_Tp* __p, _Arg __x) const
  1020.       { return (__p->*_M_f)(__x); }
  1021.  
  1022.     private:
  1023.       _Ret (_Tp::*_M_f)(_Arg);
  1024.     };
  1025.  
  1026.   /// One of the @link memory_adaptors adaptors for member
  1027.   /// pointers@endlink.
  1028.   template<typename _Ret, typename _Tp, typename _Arg>
  1029.     class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
  1030.     {
  1031.     public:
  1032.       explicit
  1033.       const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
  1034.       : _M_f(__pf) { }
  1035.  
  1036.       _Ret
  1037.       operator()(const _Tp* __p, _Arg __x) const
  1038.       { return (__p->*_M_f)(__x); }
  1039.  
  1040.     private:
  1041.       _Ret (_Tp::*_M_f)(_Arg) const;
  1042.     };
  1043.  
  1044.   /// One of the @link memory_adaptors adaptors for member
  1045.   /// pointers@endlink.
  1046.   template<typename _Ret, typename _Tp, typename _Arg>
  1047.     class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
  1048.     {
  1049.     public:
  1050.       explicit
  1051.       mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
  1052.       : _M_f(__pf) { }
  1053.  
  1054.       _Ret
  1055.       operator()(_Tp& __r, _Arg __x) const
  1056.       { return (__r.*_M_f)(__x); }
  1057.  
  1058.     private:
  1059.       _Ret (_Tp::*_M_f)(_Arg);
  1060.     };
  1061.  
  1062.   /// One of the @link memory_adaptors adaptors for member
  1063.   /// pointers@endlink.
  1064.   template<typename _Ret, typename _Tp, typename _Arg>
  1065.     class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
  1066.     {
  1067.     public:
  1068.       explicit
  1069.       const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
  1070.       : _M_f(__pf) { }
  1071.  
  1072.       _Ret
  1073.       operator()(const _Tp& __r, _Arg __x) const
  1074.       { return (__r.*_M_f)(__x); }
  1075.  
  1076.     private:
  1077.       _Ret (_Tp::*_M_f)(_Arg) const;
  1078.     };
  1079.  
  1080.   // Mem_fun adaptor helper functions.  There are only two:
  1081.   // mem_fun and mem_fun_ref.
  1082.   template<typename _Ret, typename _Tp>
  1083.     inline mem_fun_t<_Ret, _Tp>
  1084.     mem_fun(_Ret (_Tp::*__f)())
  1085.     { return mem_fun_t<_Ret, _Tp>(__f); }
  1086.  
  1087.   template<typename _Ret, typename _Tp>
  1088.     inline const_mem_fun_t<_Ret, _Tp>
  1089.     mem_fun(_Ret (_Tp::*__f)() const)
  1090.     { return const_mem_fun_t<_Ret, _Tp>(__f); }
  1091.  
  1092.   template<typename _Ret, typename _Tp>
  1093.     inline mem_fun_ref_t<_Ret, _Tp>
  1094.     mem_fun_ref(_Ret (_Tp::*__f)())
  1095.     { return mem_fun_ref_t<_Ret, _Tp>(__f); }
  1096.  
  1097.   template<typename _Ret, typename _Tp>
  1098.     inline const_mem_fun_ref_t<_Ret, _Tp>
  1099.     mem_fun_ref(_Ret (_Tp::*__f)() const)
  1100.     { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
  1101.  
  1102.   template<typename _Ret, typename _Tp, typename _Arg>
  1103.     inline mem_fun1_t<_Ret, _Tp, _Arg>
  1104.     mem_fun(_Ret (_Tp::*__f)(_Arg))
  1105.     { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
  1106.  
  1107.   template<typename _Ret, typename _Tp, typename _Arg>
  1108.     inline const_mem_fun1_t<_Ret, _Tp, _Arg>
  1109.     mem_fun(_Ret (_Tp::*__f)(_Arg) const)
  1110.     { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
  1111.  
  1112.   template<typename _Ret, typename _Tp, typename _Arg>
  1113.     inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
  1114.     mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
  1115.     { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
  1116.  
  1117.   template<typename _Ret, typename _Tp, typename _Arg>
  1118.     inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
  1119.     mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
  1120.     { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
  1121.  
  1122.   /** @}  */
  1123.  
  1124. _GLIBCXX_END_NAMESPACE_VERSION
  1125. } // namespace
  1126.  
  1127. #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
  1128. # include <backward/binders.h>
  1129. #endif
  1130.  
  1131. #endif /* _STL_FUNCTION_H */
  1132.