Uses of std::binary_function and std::unary_function in Boost 1.61

accumulators/numeric/functional/valarray.hpp:

  120:        struct Name<Left, Right, std_valarray_tag, std_valarray_tag>
  121:          : std::binary_function<
  --
  147:        struct Name<Left, Right, std_valarray_tag, void>
  148:          : std::binary_function<
  --
  169:        struct Name<Left, Right, void, std_valarray_tag>
  170:          : std::binary_function<
  --
  202:        struct min_assign<Left, Right, std_valarray_tag, std_valarray_tag>
  203:          : std::binary_function<Left, Right, void>
  --
  221:        struct max_assign<Left, Right, std_valarray_tag, std_valarray_tag>
  222:          : std::binary_function<Left, Right, void>
  --
  249:        struct promote<To, From, std_valarray_tag, std_valarray_tag>
  250:          : std::unary_function<From, To>
  --
  264:        struct promote<ToFrom, ToFrom, std_valarray_tag, std_valarray_tag>
  265:          : std::unary_function<ToFrom, ToFrom>
  --
  277:        struct promote<bool, From, void, std_valarray_tag>
  278:          : std::unary_function<From, bool>
  --
  302:        struct as_min<T, std_valarray_tag>
  303:            : std::unary_function<T, typename remove_const<T>::type>
  --
  316:        struct as_max<T, std_valarray_tag>
  317:          : std::unary_function<T, typename remove_const<T>::type>
  --
  330:        struct as_zero<T, std_valarray_tag>
  331:          : std::unary_function<T, typename remove_const<T>::type>
  --
  344:        struct as_one<T, std_valarray_tag>
  345:          : std::unary_function<T, typename remove_const<T>::type>

accumulators/numeric/functional/vector.hpp:

  197:        struct min_assign<Left, Right, std_vector_tag, std_vector_tag>
  198:          : std::binary_function<Left, Right, void>
  --
  216:        struct max_assign<Left, Right, std_vector_tag, std_vector_tag>
  217:          : std::binary_function<Left, Right, void>
  --
  244:        struct promote<To, From, std_vector_tag, std_vector_tag>
  245:          : std::unary_function<From, To>
  --
  259:        struct promote<ToFrom, ToFrom, std_vector_tag, std_vector_tag>
  260:          : std::unary_function<ToFrom, ToFrom>
  --
  271:        struct as_min<T, std_vector_tag>
  272:          : std::unary_function<T, typename remove_const<T>::type>
  --
  285:        struct as_max<T, std_vector_tag>
  286:          : std::unary_function<T, typename remove_const<T>::type>
  --
  299:        struct as_zero<T, std_vector_tag>
  300:          : std::unary_function<T, typename remove_const<T>::type>
  --
  313:        struct as_one<T, std_vector_tag>
  314:          : std::unary_function<T, typename remove_const<T>::type>

accumulators/numeric/functional.hpp:

  101:        struct Name ## _base
  102:          : std::unary_function<
  --
  140:        struct Name ## _base
  141:          : std::binary_function<
  --
  222:        struct min_assign_base
  223:          : std::binary_function<Left, Right, void>
  --
  235:        struct max_assign_base
  236:          : std::binary_function<Left, Right, void>
  --
  260:        struct promote_base
  261:          : std::unary_function<From, To>
  --
  270:        struct promote_base<ToFrom, ToFrom, void>
  271:          : std::unary_function<ToFrom, ToFrom>
  --
  280:        struct as_min_base
  281:          : std::unary_function<Arg, typename remove_const<Arg>::type>
  --
  292:        struct as_min_base<Arg, typename enable_if<is_floating_point<Arg> >::type>
  293:          : std::unary_function<Arg, typename remove_const<Arg>::type>
  --
  304:        struct as_max_base
  305:          : std::unary_function<Arg, typename remove_const<Arg>::type>
  --
  316:        struct as_zero_base
  317:          : std::unary_function<Arg, typename remove_const<Arg>::type>
  --
  326:        struct as_one_base
  327:          : std::unary_function<Arg, typename remove_const<Arg>::type>

accumulators/statistics/covariance.hpp:

  52:        struct outer_product<Left, Right, std_vector_tag, std_vector_tag>
  53:          : std::binary_function<

accumulators/statistics/tail.hpp:

  250:        struct indirect_cmp
  251:          : std::binary_function<std::size_t, std::size_t, bool>

algorithm/cxx14/equal.hpp:

  22:    template <class T1, class T2>
  23:    struct eq : public std::binary_function<T1, T2, bool> {

algorithm/string/detail/case_conv.hpp:

  32:            template<typename CharT>
  33:            struct to_lowerF : public std::unary_function<CharT, CharT>
  --
  52:            template<typename CharT>
  53:            struct to_upperF : public std::unary_function<CharT, CharT>

algorithm/string/detail/util.hpp:

  92:            struct copy_iterator_rangeF : 
  93:                public std::unary_function< iterator_range<IteratorT>, SeqT >

bimap/container_adaptor/detail/comparison_adaptor.hpp:

  35:template < class Compare, class NewType, class Converter >
  36:struct comparison_adaptor : std::binary_function<NewType,NewType,bool>
  --
  52:template < class Compare, class NewType, class Converter >
  53:struct compatible_comparison_adaptor : std::binary_function<NewType,NewType,bool>
  --
  77:template < class Compare, class NewType, class Converter >
  78:struct unary_check_adaptor : std::unary_function<NewType,bool>

bimap/container_adaptor/detail/key_extractor.hpp:

  31:struct key_from_pair_extractor 
  32:    : std::unary_function< T, BOOST_DEDUCED_TYPENAME T::first_type >

bimap/detail/modifier_adaptor.hpp:

  36:struct relation_modifier_adaptor :
  37:    public std::unary_function<NewArgument,bool>,
  --
  67:struct unary_modifier_adaptor :
  68:    public std::unary_function<NewArgument,bool>,

bimap/relation/support/data_extractor.hpp:

  42:struct data_extractor_implementation< member_at::left, Relation > :
  43:    public std::unary_function<Relation,BOOST_DEDUCED_TYPENAME Relation::left_value_type>
  --
  59:struct data_extractor_implementation< member_at::right, Relation > :
  60:    public std::unary_function<Relation,BOOST_DEDUCED_TYPENAME Relation::right_value_type>

function/function_template.hpp:

  660:#if BOOST_FUNCTION_NUM_ARGS == 1
  661:
  662:    , public std::unary_function<T0,R>
  663:
  664:#elif BOOST_FUNCTION_NUM_ARGS == 2
  665:
  666:    , public std::binary_function<T0,T1,R>
  667:
  668:#endif

functional/hash/extensions.hpp:

  256:    template <class T> struct hash
  257:        : std::unary_function<T, std::size_t>
  --
  273:    template <class T, unsigned int n> struct hash<T[n]>
  274:        : std::unary_function<T[n], std::size_t>
  --
  298:            struct inner
  299:                : std::unary_function<T, std::size_t>

functional/hash/hash.hpp:

  419:    template <> struct hash<type> \
  420:         : public std::unary_function<type, std::size_t> \
  --
  429:    template <> struct hash<type> \
  430:         : public std::unary_function<type, std::size_t> \
  --
  483:    struct hash<T*>
  484:        : public std::unary_function<T*, std::size_t>
  --
  516:            struct inner
  517:                : public std::unary_function<T, std::size_t>

functional.hpp:

  149:    class unary_negate
  150:        : public std::unary_function<typename unary_traits<Predicate>::argument_type,bool>
  --
  183:    class binary_negate
  184:        : public std::binary_function<typename binary_traits<Predicate>::first_argument_type,
  --
  220:    class binder1st
  221:        : public std::unary_function<typename binary_traits<Operation>::second_argument_type,
  --
  266:    class binder2nd
  267:        : public std::unary_function<typename binary_traits<Operation>::first_argument_type,
  --
  311:    template <class S, class T>
  312:    class mem_fun_t : public std::unary_function<T*, S>
  --
  327:    template <class S, class T, class A>
  328:    class mem_fun1_t : public std::binary_function<T*, A, S>
  --
  343:    template <class S, class T>
  344:    class const_mem_fun_t : public std::unary_function<const T*, S>
  --
  359:    template <class S, class T, class A>
  360:    class const_mem_fun1_t : public std::binary_function<const T*, A, S>
  --
  404:    template <class S, class T>
  405:    class mem_fun_ref_t : public std::unary_function<T&, S>
  --
  420:    template <class S, class T, class A>
  421:    class mem_fun1_ref_t : public std::binary_function<T&, A, S>
  --
  436:    template <class S, class T>
  437:    class const_mem_fun_ref_t : public std::unary_function<const T&, S>
  --
  453:    template <class S, class T, class A>
  454:    class const_mem_fun1_ref_t : public std::binary_function<const T&, A, S>
  --
  499:    template <class Arg, class Result>
  500:    class pointer_to_unary_function : public std::unary_function<Arg,Result>
  --
  523:    template <class Arg1, class Arg2, class Result>
  524:    class pointer_to_binary_function : public std::binary_function<Arg1,Arg2,Result>

gil/channel_algorithm.hpp:

  134:template <typename SrcChannelV, typename DstChannelV, bool SrcIsIntegral, bool DstIsIntegral> 
  135:struct channel_converter_unsigned_impl : public std::unary_function<DstChannelV,SrcChannelV> {
  --
  271:template <typename DstChannelV> struct channel_converter_unsigned<bits32f,DstChannelV> : public std::unary_function<bits32f,DstChannelV> {
  --
  279:template <typename SrcChannelV> struct channel_converter_unsigned<SrcChannelV,bits32f> : public std::unary_function<SrcChannelV,bits32f> {
  --
  283:template <> struct channel_converter_unsigned<bits32f,bits32f> : public std::unary_function<bits32f,bits32f> {
  --
  289:template <> struct channel_converter_unsigned<bits32,bits32f> : public std::unary_function<bits32,bits32f> {
  --
  297:template <> struct channel_converter_unsigned<bits32f,bits32> : public std::unary_function<bits32f,bits32> {
  --
  315:template <> struct channel_convert_to_unsigned<bits8s> : public std::unary_function<bits8s,bits8> { 
  --
  320:template <> struct channel_convert_to_unsigned<bits16s> : public std::unary_function<bits16s,bits16> { 
  --
  325:template <> struct channel_convert_to_unsigned<bits32s> : public std::unary_function<bits32s,bits32> {
  --
  338:template <> struct channel_convert_from_unsigned<bits8s> : public std::unary_function<bits8,bits8s> { 
  --
  343:template <> struct channel_convert_from_unsigned<bits16s> : public std::unary_function<bits16,bits16s> { 
  --
  348:template <> struct channel_convert_from_unsigned<bits32s> : public std::unary_function<bits32,bits32s> {
  --
  357:template <typename SrcChannelV, typename DstChannelV> // Model ChannelValueConcept
  358:struct channel_converter : public std::unary_function<SrcChannelV,DstChannelV> {
  --
  410:template <typename ChannelValue>
  411:struct channel_multiplier_unsigned : public std::binary_function<ChannelValue,ChannelValue,ChannelValue> {
  --
  418:template<> struct channel_multiplier_unsigned<bits8> : public std::binary_function<bits8,bits8,bits8> {
  --
  423:template<> struct channel_multiplier_unsigned<bits16> : public std::binary_function<bits16,bits16,bits16> {
  --
  428:template<> struct channel_multiplier_unsigned<bits32f> : public std::binary_function<bits32f,bits32f,bits32f> {
  --
  433:template <typename ChannelValue>
  434:struct channel_multiplier : public std::binary_function<ChannelValue, ChannelValue, ChannelValue> {

gil/gil_concept.hpp:

  1106:template <typename P>
  1107:struct PixelDereferenceAdaptorArchetype : public std::unary_function<P, P> {

gil/utilities.hpp:

  181:          typename ArgType, typename ResultType, bool IsMutable>
  182:struct deref_base : public std::unary_function<ArgType, ResultType> {
  --
  262:template <typename T> 
  263:struct identity : public std::unary_function<T,T> {
  --
  270:template <typename T1, typename T2>
  271:struct plus_asymmetric : public std::binary_function<T1,T2,T1> {
  --
  280:template <typename T>
  281:struct inc : public std::unary_function<T,T> {
  --
  288:template <typename T>
  289:struct dec : public std::unary_function<T,T> {

graph/astar_search.hpp:

  48:  template <class Graph, class CostType>
  49:  class astar_heuristic : public std::unary_function<

graph/detail/geodesic.hpp:

  84:    template <typename T>
  85:    struct maximize : public std::binary_function<T, T, T>
  --
  95:    template <typename T>
  96:    struct reciprocal : public std::unary_function<T, T>
  97:    {
  98:        typedef std::unary_function<T, T> function_type;

graph/distributed/crauser_et_al_shortest_paths.hpp:

  97:  struct min_in_distance_compare
  98:    : std::binary_function<Vertex, Vertex, bool>
  --
  122:  struct min_out_distance_compare
  123:    : std::binary_function<Vertex, Vertex, bool>

graph/parallel/algorithm.hpp:

  28:  template<typename T>
  29:  struct minimum : std::binary_function<T, T, T>
  --
  34:  template<typename T>
  35:  struct maximum : std::binary_function<T, T, T>
  --
  40:  template<typename T>
  41:  struct sum : std::binary_function<T, T, T>

graph/transitive_closure.hpp:

  43:      typename VT = typename TheContainer::value_type >
  44:      struct subscript_t:public std::unary_function < ST, VT >

icl/functors.hpp:

  22:    template <typename Type> struct identity_based_inplace_combine 
  23:        : public std::binary_function<Type&, const Type&, void>
  --
  29:    template <typename Type> struct unit_element_based_inplace_combine 
  30:        : public std::binary_function<Type&, const Type&, void>

icl/type_traits/predicate.hpp:

  22:    template <class Type>
  23:    class property : public std::unary_function<Type,bool>{};
  --
  37:    template <class LeftT, class RightT>
  38:    class relation : public std::binary_function<LeftT,RightT,bool>{};

interprocess/indexes/iunordered_set_index.hpp:

  91:    struct hash_function
  92:      : std::unary_function<value_type, std::size_t>

interprocess/indexes/unordered_map_index.hpp:

  56:    struct hasher
  57:      : std::unary_function<key_type, std::size_t>

iostreams/chain.hpp:

  294:    struct closer  : public std::unary_function<streambuf_type*, void>  {

mpi/operations.hpp:

  57:template<typename T>
  58:struct maximum : public std::binary_function<T, T, T>
  --
  74:template<typename T>
  75:struct minimum : public std::binary_function<T, T, T>
  --
  92:template<typename T>
  93:struct bitwise_and : public std::binary_function<T, T, T>
  --
  109:template<typename T>
  110:struct bitwise_or : public std::binary_function<T, T, T>
  --
  126:template<typename T>
  127:struct logical_xor : public std::binary_function<T, T, T>
  --
  144:template<typename T>
  145:struct bitwise_xor : public std::binary_function<T, T, T>

msm/back/bind_helpers.hpp:

  20:    struct plus2
  21:        : public std::binary_function<_Ty, _Tz, _Ty>

numeric/conversion/detail/converter.hpp:

  452:  template<class Traits>
  453:  struct trivial_converter_impl : public std::unary_function<  BOOST_DEDUCED_TYPENAME Traits::argument_type
  --
  473:  template<class Traits,class RangeChecker,class RawConverter,class Float2IntRounder>
  474:  struct rounding_converter : public std::unary_function<  BOOST_DEDUCED_TYPENAME Traits::argument_type
  --
  503:  template<class Traits,class RangeChecker,class RawConverter>
  504:  struct non_rounding_converter : public std::unary_function< BOOST_DEDUCED_TYPENAME Traits::argument_type

polygon/detail/boolean_op_45.hpp:

  153:    class lessScan45ElementRise : public std::binary_function<Scan45Element, Scan45Element, bool> {
  --
  460:      class lessScan45Point : public std::binary_function<Point, Point, bool> {

polygon/detail/max_cover.hpp:

  39:    class lessEdgeAssociation : public std::binary_function<const EdgeAssociation&, const EdgeAssociation&, bool> {

polygon/detail/polygon_arbitrary_formation.hpp:

  25:    class less_point : public std::binary_function<Point, Point, bool> {
  --
  267:    class less_half_edge : public std::binary_function<half_edge, half_edge, bool> {
  --
  764:    class less_vertex_half_edge : public std::binary_function<vertex_half_edge, vertex_half_edge, bool> {
  --
  1198:    class less_half_edge_count : public std::binary_function<vertex_half_edge, vertex_half_edge, bool> {
  --
  1216:    class less_incoming_count : public std::binary_function<std::pair<std::pair<std::pair<Point, Point>, int>, active_tail_arbitrary*>,

polygon/detail/scan_arbitrary.hpp:

  319:    class less_point_down_slope : public std::binary_function<Point, Point, bool> {

polygon/polygon_traits.hpp:

  1186:    class less_point : public std::binary_function<Point, Point, bool> {

signals2/detail/variadic_arg_type.hpp:

  38:      template <typename R, typename T1>
  39:        struct std_functional_base<R, T1>: public std::unary_function<T1, R>
  --
  41:      template <typename R, typename T1, typename T2>
  42:        struct std_functional_base<R, T1, T2>: public std::binary_function<T1, T2, R>

smart_ptr/owner_less.hpp:

  25:    template<typename T, typename U>
  26:      struct generic_owner_less : public std::binary_function<T, T, bool>

test/utils/basic_cstring/compare.hpp:

  78:template<class CharT>
  79:class case_ins_less : public std::binary_function<basic_cstring<CharT>,basic_cstring<CharT>,bool>

typeof/std/functional.hpp:

  13:BOOST_TYPEOF_REGISTER_TEMPLATE(std::unary_function, 2)
  14:BOOST_TYPEOF_REGISTER_TEMPLATE(std::binary_function, 3)

utility/compare_pointees.hpp:

  35:template<class OptionalPointee>
  36:struct equal_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
  --
  58:template<class OptionalPointee>
  59:struct less_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>

xpressive/detail/utility/tracking_ptr.hpp:

  114:struct filter_self
  115:  : std::unary_function<shared_ptr<Derived>, bool>

xpressive/match_results.hpp:

  1356:struct regex_id_filter_predicate
  1357:  : std::unary_function<match_results<BidiIter>, bool>