778 lines
20 KiB
C++
778 lines
20 KiB
C++
// -*- C++ -*-
|
|
/***************************************************************************
|
|
*
|
|
* functional - global template functions
|
|
*
|
|
* $Id: functional 550991 2007-06-26 23:58:07Z sebor $
|
|
*
|
|
***************************************************************************
|
|
*
|
|
* Copyright (c) 1994
|
|
* Hewlett-Packard Company
|
|
*
|
|
* Permission to use, copy, modify, distribute and sell this software
|
|
* and its documentation for any purpose is hereby granted without fee,
|
|
* provided that the above copyright notice appear in all copies and
|
|
* that both that copyright notice and this permission notice appear
|
|
* in supporting documentation. Hewlett-Packard Company makes no
|
|
* representations about the suitability of this software for any
|
|
* purpose. It is provided "as is" without express or implied warranty.
|
|
*
|
|
***************************************************************************
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
* implied. See the License for the specific language governing
|
|
* permissions and limitations under the License.
|
|
*
|
|
* Copyright 1994-2006 Rogue Wave Software.
|
|
*
|
|
**************************************************************************/
|
|
|
|
#ifndef _RWSTD_FUNCTIONAL_INCLUDED
|
|
#define _RWSTD_FUNCTIONAL_INCLUDED
|
|
|
|
|
|
#include <rw/_funcbase.h>
|
|
#include <rw/_defs.h>
|
|
|
|
|
|
_RWSTD_NAMESPACE (std) {
|
|
|
|
|
|
// 20.3.2 - Arithmetic operations
|
|
|
|
// 20.3.2, p2
|
|
template <class _TypeT>
|
|
struct plus : binary_function<_TypeT, _TypeT, _TypeT>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT);
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
const second_argument_type &__y) const {
|
|
return __x + __y;
|
|
}
|
|
};
|
|
|
|
|
|
// 20.3.2, p3
|
|
template <class _TypeT>
|
|
struct minus : binary_function<_TypeT, _TypeT, _TypeT>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT);
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
const second_argument_type &__y) const {
|
|
return __x - __y;
|
|
}
|
|
};
|
|
|
|
|
|
// 20.3.2, p4
|
|
template <class _TypeT>
|
|
struct multiplies : binary_function<_TypeT, _TypeT, _TypeT>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT);
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
const second_argument_type &__y) const {
|
|
return __x * __y;
|
|
}
|
|
};
|
|
|
|
|
|
// 20.3.2, p5
|
|
template <class _TypeT>
|
|
struct divides : binary_function<_TypeT, _TypeT, _TypeT>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT);
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
const second_argument_type &__y) const {
|
|
return __x / __y;
|
|
}
|
|
};
|
|
|
|
|
|
// 20.3.2, p6
|
|
template <class _TypeT>
|
|
struct modulus : binary_function<_TypeT, _TypeT, _TypeT>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT);
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
const second_argument_type &__y) const {
|
|
return __x % __y;
|
|
}
|
|
};
|
|
|
|
|
|
// 20.3.2, p7
|
|
template <class _TypeT>
|
|
struct negate : unary_function<_TypeT, _TypeT>
|
|
{
|
|
_RWSTD_UNARY_FUNCTION_TYPES (_TypeT, _TypeT);
|
|
|
|
result_type operator() (const argument_type &__x) const {
|
|
return -__x;
|
|
}
|
|
};
|
|
|
|
|
|
// 20.3.3 - Comparisons
|
|
|
|
|
|
// 20.3.3, p2
|
|
template <class _TypeT>
|
|
struct equal_to : binary_function<_TypeT, _TypeT, bool>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, bool);
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
const second_argument_type &__y) const {
|
|
return __x == __y;
|
|
}
|
|
};
|
|
|
|
|
|
// 20.3.3, p3
|
|
template <class _TypeT>
|
|
struct not_equal_to : binary_function<_TypeT, _TypeT, bool>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, bool);
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
const second_argument_type &__y) const {
|
|
return __x != __y;
|
|
}
|
|
};
|
|
|
|
|
|
// 20.3.3, p4
|
|
template <class _TypeT>
|
|
struct greater : binary_function<_TypeT, _TypeT, bool>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, bool);
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
const second_argument_type &__y) const {
|
|
return __x > __y;
|
|
}
|
|
};
|
|
|
|
|
|
// 20.3.3, p5 - defined in <rw/_funcbase.h>
|
|
template <class _TypeT>
|
|
struct less;
|
|
|
|
|
|
// 20.3.3, p6
|
|
template <class _TypeT>
|
|
struct greater_equal : binary_function<_TypeT, _TypeT, bool>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, bool);
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
const second_argument_type &__y) const {
|
|
return __x >= __y;
|
|
}
|
|
};
|
|
|
|
|
|
// 20.3.3, p7
|
|
template <class _TypeT>
|
|
struct less_equal : binary_function<_TypeT, _TypeT, bool>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, bool);
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
const second_argument_type &__y) const {
|
|
return __x <= __y;
|
|
}
|
|
};
|
|
|
|
|
|
// 20.3.4 - Logical operations
|
|
|
|
// 20.3.4, p2
|
|
template <class _TypeT>
|
|
struct logical_and : binary_function<_TypeT, _TypeT, bool>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, bool);
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
const second_argument_type &__y) const {
|
|
return __x && __y;
|
|
}
|
|
};
|
|
|
|
|
|
// 20.3.4, p3
|
|
template <class _TypeT>
|
|
struct logical_or : binary_function<_TypeT, _TypeT, bool>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, bool);
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
const second_argument_type &__y) const {
|
|
return __x || __y;
|
|
}
|
|
};
|
|
|
|
// 20.3.4, p4
|
|
template <class _TypeT>
|
|
struct logical_not : unary_function<_TypeT, bool>
|
|
{
|
|
_RWSTD_UNARY_FUNCTION_TYPES (_TypeT, bool);
|
|
|
|
result_type operator() (const _TypeT &__x) const {
|
|
return !__x;
|
|
}
|
|
};
|
|
|
|
|
|
// 20.3.5 - Negators
|
|
|
|
// 20.3.5, p2
|
|
template <class _Predicate>
|
|
class unary_negate
|
|
: public unary_function<_TYPENAME _Predicate::argument_type, bool>
|
|
{
|
|
_Predicate _C_pred;
|
|
public:
|
|
_RWSTD_UNARY_FUNCTION_TYPES (_TYPENAME _Predicate::argument_type, bool);
|
|
|
|
_EXPLICIT unary_negate (const _Predicate &__pred) : _C_pred (__pred) { }
|
|
|
|
result_type operator() (const argument_type &__x) const {
|
|
return !_C_pred (__x);
|
|
}
|
|
};
|
|
|
|
|
|
// 20.3.5, p3
|
|
template <class _Predicate>
|
|
inline unary_negate<_Predicate> not1 (const _Predicate &__pred)
|
|
{
|
|
return unary_negate<_Predicate>(__pred);
|
|
}
|
|
|
|
|
|
// 20.3.5, p4
|
|
template <class _Predicate>
|
|
class binary_negate
|
|
: public binary_function<_TYPENAME _Predicate::first_argument_type,
|
|
_TYPENAME _Predicate::second_argument_type, bool>
|
|
{
|
|
_Predicate _C_pred;
|
|
public:
|
|
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TYPENAME _Predicate::first_argument_type,
|
|
_TYPENAME _Predicate::second_argument_type,
|
|
bool);
|
|
|
|
_EXPLICIT binary_negate (const _Predicate &__pred) : _C_pred (__pred) { }
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
const second_argument_type &__y) const {
|
|
return !_C_pred (__x, __y);
|
|
}
|
|
};
|
|
|
|
|
|
// 20.3.5, p5
|
|
template <class _Predicate>
|
|
inline binary_negate<_Predicate> not2 (const _Predicate &__pred)
|
|
{
|
|
return binary_negate<_Predicate>(__pred);
|
|
}
|
|
|
|
|
|
// 20.3.6 - Binders
|
|
|
|
// 20.3.6.1
|
|
template <class _Operation>
|
|
class binder1st
|
|
: public unary_function<_TYPENAME _Operation::second_argument_type,
|
|
_TYPENAME _Operation::result_type>
|
|
{
|
|
protected:
|
|
_Operation op;
|
|
_TYPENAME _Operation::first_argument_type value;
|
|
public:
|
|
|
|
_RWSTD_UNARY_FUNCTION_TYPES (_TYPENAME _Operation::second_argument_type,
|
|
_TYPENAME _Operation::result_type);
|
|
|
|
binder1st (const _Operation &__oper,
|
|
const _TYPENAME _Operation::first_argument_type &__x)
|
|
: op (__oper), value (__x) { }
|
|
|
|
result_type
|
|
operator() (const argument_type &__y) const {
|
|
return op (value, __y);
|
|
}
|
|
};
|
|
|
|
|
|
// 20.3.6.2
|
|
template <class _Operation, class _TypeT>
|
|
inline binder1st<_Operation>
|
|
bind1st (const _Operation &__oper, const _TypeT &__x)
|
|
{
|
|
typedef _TYPENAME _Operation::first_argument_type first_argument_type;
|
|
|
|
return binder1st<_Operation>(__oper, first_argument_type (__x));
|
|
}
|
|
|
|
|
|
// 20.3.6.3
|
|
template <class _Operation>
|
|
class binder2nd
|
|
: public unary_function<_TYPENAME _Operation::first_argument_type,
|
|
_TYPENAME _Operation::result_type>
|
|
{
|
|
protected:
|
|
_Operation op;
|
|
_TYPENAME _Operation::second_argument_type value;
|
|
public:
|
|
|
|
_RWSTD_UNARY_FUNCTION_TYPES (_TYPENAME _Operation::first_argument_type,
|
|
_TYPENAME _Operation::result_type);
|
|
|
|
binder2nd (const _Operation &__oper,
|
|
const _TYPENAME _Operation::second_argument_type &__y)
|
|
: op (__oper), value (__y) { }
|
|
|
|
result_type
|
|
operator() (const argument_type &__x) const {
|
|
return op (__x, value);
|
|
}
|
|
};
|
|
|
|
|
|
// 20.3.6.4
|
|
template <class _Operation, class _TypeT>
|
|
inline binder2nd<_Operation>
|
|
bind2nd (const _Operation &__oper, const _TypeT &__x)
|
|
{
|
|
typedef _TYPENAME _Operation::second_argument_type second_argument_type;
|
|
return binder2nd<_Operation>(__oper, second_argument_type (__x));
|
|
}
|
|
|
|
|
|
// 20.3.7 - Adaptors for pointers to functions
|
|
|
|
// 20.3.7, p2
|
|
template <class _Arg, class _Result>
|
|
struct pointer_to_unary_function : unary_function<_Arg, _Result>
|
|
{
|
|
_RWSTD_UNARY_FUNCTION_TYPES (_Arg, _Result);
|
|
|
|
_EXPLICIT pointer_to_unary_function (result_type (*__fun)(argument_type))
|
|
: _C_fn (__fun) {}
|
|
|
|
result_type operator() (argument_type __x) const {
|
|
return _C_fn (__x);
|
|
}
|
|
|
|
private:
|
|
result_type (*_C_fn)(argument_type);
|
|
};
|
|
|
|
|
|
// 20.3.7, p3
|
|
template <class _Arg, class _Result>
|
|
inline pointer_to_unary_function<_Arg, _Result>
|
|
ptr_fun (_Result (*__fun)(_Arg))
|
|
{
|
|
return pointer_to_unary_function<_Arg, _Result>(__fun);
|
|
}
|
|
|
|
|
|
// 20.3.7, p4
|
|
template <class _Arg1, class _Arg2, class _Result>
|
|
struct pointer_to_binary_function
|
|
: binary_function<_Arg1, _Arg2, _Result>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_Arg1, _Arg2, _Result);
|
|
|
|
_EXPLICIT
|
|
pointer_to_binary_function (result_type (*__fun)(first_argument_type,
|
|
second_argument_type))
|
|
: _C_fn (__fun) { }
|
|
|
|
result_type operator() (first_argument_type __x,
|
|
second_argument_type __y) const {
|
|
return _C_fn (__x, __y);
|
|
}
|
|
|
|
private:
|
|
result_type (*_C_fn)(first_argument_type, second_argument_type);
|
|
};
|
|
|
|
|
|
// 20.3.7, p5
|
|
template <class _Arg1, class _Arg2, class _Result>
|
|
inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
|
|
ptr_fun (_Result (*__fun)(_Arg1, _Arg2))
|
|
{
|
|
return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__fun);
|
|
}
|
|
|
|
|
|
// 20.3.8 - Adaptors for pointers to members
|
|
|
|
// 20.3.8, p2 - adaptor for a non-const member function taking no arguments
|
|
// operating on a pointer to a non-const object
|
|
template <class _Result, class _TypeT>
|
|
struct mem_fun_t: unary_function<_TypeT*, _Result>
|
|
{
|
|
_RWSTD_UNARY_FUNCTION_TYPES (_TypeT*, _Result);
|
|
|
|
_EXPLICIT mem_fun_t (result_type (_TypeT::*__fun)()) : _C_fn (__fun) { }
|
|
|
|
result_type operator() (argument_type __x) const {
|
|
return (__x->*_C_fn)();
|
|
}
|
|
|
|
private:
|
|
result_type (_TypeT::*_C_fn)();
|
|
};
|
|
|
|
|
|
// 20.3.8, p3 - adaptor for a non-const member function taking one argument
|
|
// operating on a pointer to a non-const object
|
|
template <class _Result, class _TypeT, class _Arg>
|
|
struct mem_fun1_t: binary_function<_TypeT*, _Arg, _Result>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT*, _Arg, _Result);
|
|
|
|
_EXPLICIT
|
|
mem_fun1_t (result_type (_TypeT::*__fun)(second_argument_type))
|
|
: _C_fn (__fun) { }
|
|
|
|
result_type operator() (first_argument_type __x,
|
|
second_argument_type __y) const {
|
|
return (__x->*_C_fn)(__y);
|
|
}
|
|
|
|
private:
|
|
result_type (_TypeT::*_C_fn)(second_argument_type);
|
|
};
|
|
|
|
|
|
// 20.3.8, p4
|
|
template <class _Result, class _TypeT>
|
|
inline mem_fun_t<_Result, _TypeT> mem_fun (_Result (_TypeT::*__fun)())
|
|
{
|
|
return mem_fun_t<_Result, _TypeT>(__fun);
|
|
}
|
|
|
|
|
|
template <class _Result, class _TypeT, class _Arg>
|
|
inline mem_fun1_t<_Result, _TypeT, _Arg>
|
|
mem_fun (_Result (_TypeT::*__fun)(_Arg))
|
|
{
|
|
return mem_fun1_t<_Result, _TypeT, _Arg>(__fun);
|
|
}
|
|
|
|
|
|
// 20.3.8, p5 - adaptor for a non-const member function taking no arguments
|
|
// operating on a non-const object
|
|
template <class _Result, class _TypeT>
|
|
struct mem_fun_ref_t: unary_function<_TypeT, _Result>
|
|
{
|
|
_RWSTD_UNARY_FUNCTION_TYPES (_TypeT, _Result);
|
|
|
|
_EXPLICIT mem_fun_ref_t (result_type (_TypeT::*__fun)()) : _C_fn (__fun) { }
|
|
|
|
result_type operator() (argument_type &__x) const {
|
|
return (__x.*_C_fn)();
|
|
}
|
|
|
|
private:
|
|
result_type (_TypeT::*_C_fn)();
|
|
};
|
|
|
|
|
|
// 20.3.8, p6 - adaptor for a non-const member function taking one argument
|
|
// operating on a non-const object
|
|
template <class _Result, class _TypeT, class _Arg>
|
|
struct mem_fun1_ref_t : binary_function<_TypeT, _Arg, _Result>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _Arg, _Result);
|
|
|
|
_EXPLICIT
|
|
mem_fun1_ref_t (result_type (_TypeT::*__fun)(second_argument_type))
|
|
: _C_fn (__fun) { }
|
|
|
|
result_type operator() (first_argument_type &__x,
|
|
second_argument_type __y) const {
|
|
return (__x.*_C_fn)(__y);
|
|
}
|
|
|
|
private:
|
|
result_type (_TypeT::*_C_fn)(second_argument_type);
|
|
};
|
|
|
|
|
|
// 20.3.8, p7
|
|
template <class _Result, class _TypeT>
|
|
inline mem_fun_ref_t<_Result, _TypeT>
|
|
mem_fun_ref(_Result (_TypeT::*__fun)())
|
|
{
|
|
return mem_fun_ref_t<_Result, _TypeT>(__fun);
|
|
}
|
|
|
|
|
|
template <class _Result, class _TypeT, class _Arg>
|
|
inline mem_fun1_ref_t<_Result, _TypeT, _Arg>
|
|
mem_fun_ref(_Result (_TypeT::*__fun)(_Arg))
|
|
{
|
|
return mem_fun1_ref_t<_Result, _TypeT, _Arg> (__fun);
|
|
}
|
|
|
|
|
|
// 20.3.8, p8 - adaptor for a const member function taking no arguments
|
|
// operating on a const object
|
|
template <class _Result, class _TypeT>
|
|
struct const_mem_fun_t: unary_function<const _TypeT*, _Result>
|
|
{
|
|
_RWSTD_UNARY_FUNCTION_TYPES (const _TypeT*, _Result);
|
|
|
|
_EXPLICIT const_mem_fun_t (result_type (_TypeT::*__fun)() const)
|
|
: _C_fn (__fun) { }
|
|
|
|
result_type operator() (argument_type __x) const {
|
|
return (__x->*_C_fn)();
|
|
}
|
|
|
|
private:
|
|
result_type (_TypeT::*_C_fn)() const;
|
|
};
|
|
|
|
|
|
// 20.3.8, p9 - adaptor for a const member function taking one argument
|
|
// operating on a const object
|
|
template <class _Result, class _TypeT, class _Arg>
|
|
struct const_mem_fun1_t: binary_function<const _TypeT*, _Arg, _Result>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (const _TypeT*, _Arg, _Result);
|
|
|
|
_EXPLICIT
|
|
const_mem_fun1_t (result_type (_TypeT::*__fun)(second_argument_type) const)
|
|
: _C_fn (__fun) { }
|
|
|
|
result_type operator() (first_argument_type __x,
|
|
second_argument_type __y) const {
|
|
return (__x->*_C_fn)(__y);
|
|
}
|
|
|
|
private:
|
|
result_type (_TypeT::*_C_fn)(second_argument_type) const;
|
|
};
|
|
|
|
|
|
// 20.3.8, p10
|
|
template <class _Result, class _TypeT>
|
|
inline const_mem_fun_t<_Result, _TypeT>
|
|
mem_fun (_Result (_TypeT::*__fun)() const)
|
|
{
|
|
return const_mem_fun_t<_Result, _TypeT>(__fun);
|
|
}
|
|
|
|
|
|
template <class _Result, class _TypeT, class _Arg>
|
|
inline const_mem_fun1_t<_Result, _TypeT, _Arg>
|
|
mem_fun (_Result (_TypeT::*__fun)(_Arg) const)
|
|
{
|
|
return const_mem_fun1_t<_Result, _TypeT, _Arg>(__fun);
|
|
}
|
|
|
|
|
|
// 20.3.8, p11 - adaptor for a const member function taking no arguments
|
|
// operating on a const reference to an object
|
|
template <class _Result, class _TypeT>
|
|
struct const_mem_fun_ref_t: unary_function<_TypeT, _Result>
|
|
{
|
|
_RWSTD_UNARY_FUNCTION_TYPES (_TypeT, _Result);
|
|
|
|
_EXPLICIT const_mem_fun_ref_t (result_type (_TypeT::*__fun)() const)
|
|
: _C_fn (__fun) { }
|
|
|
|
result_type operator() (const argument_type &__x) const {
|
|
return (__x.*_C_fn)();
|
|
}
|
|
|
|
private:
|
|
result_type (_TypeT::*_C_fn)() const;
|
|
};
|
|
|
|
|
|
// 20.3.8, p12 - adaptor for a const member function taking a single argument
|
|
// operating on a const reference to an object
|
|
template <class _Result, class _TypeT, class _Arg>
|
|
struct const_mem_fun1_ref_t : binary_function<_TypeT, _Arg, _Result>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _Arg, _Result);
|
|
|
|
_EXPLICIT
|
|
const_mem_fun1_ref_t
|
|
(result_type (_TypeT::*__fun)(second_argument_type) const)
|
|
: _C_fn (__fun) { }
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
second_argument_type __y) const {
|
|
return (__x.*_C_fn)(__y);
|
|
}
|
|
|
|
private:
|
|
result_type (_TypeT::*_C_fn)(second_argument_type) const;
|
|
};
|
|
|
|
|
|
// 20.3.8, p13
|
|
template <class _Result, class _TypeT>
|
|
inline const_mem_fun_ref_t<_Result, _TypeT>
|
|
mem_fun_ref (_Result (_TypeT::*__fun)() const)
|
|
{
|
|
return const_mem_fun_ref_t<_Result, _TypeT>(__fun);
|
|
}
|
|
|
|
|
|
template <class _Result, class _TypeT, class _Arg>
|
|
inline const_mem_fun1_ref_t<_Result, _TypeT, _Arg>
|
|
mem_fun_ref (_Result (_TypeT::*__fun)(_Arg) const)
|
|
{
|
|
return const_mem_fun1_ref_t<_Result, _TypeT, _Arg>(__fun);
|
|
}
|
|
|
|
|
|
} // namespace std
|
|
|
|
|
|
_RWSTD_NAMESPACE (__rw) {
|
|
|
|
|
|
// extension: returns the argument
|
|
template <class _TypeT>
|
|
struct identity : _STD::unary_function<_TypeT, _TypeT>
|
|
{
|
|
_RWSTD_UNARY_FUNCTION_TYPES (_TypeT, _TypeT);
|
|
|
|
result_type operator() (const argument_type &__val) const {
|
|
return __val;
|
|
}
|
|
};
|
|
|
|
|
|
// extension: returns the result of applying the unary plus operator to arg
|
|
template <class _TypeT>
|
|
struct unary_plus : _STD::unary_function<_TypeT, _TypeT>
|
|
{
|
|
_RWSTD_UNARY_FUNCTION_TYPES (_TypeT, _TypeT);
|
|
|
|
result_type operator() (const argument_type &__val) const {
|
|
return +__val;
|
|
}
|
|
};
|
|
|
|
|
|
// extension: returns the bitwise complement of the argument
|
|
template <class _TypeT>
|
|
struct bitwise_complement : _STD::unary_function<_TypeT, _TypeT>
|
|
{
|
|
_RWSTD_UNARY_FUNCTION_TYPES (_TypeT, _TypeT);
|
|
|
|
result_type operator() (const argument_type &__val) const {
|
|
return ~__val;
|
|
}
|
|
};
|
|
|
|
|
|
// extension: returns the bitwise or of the two arguments
|
|
template <class _TypeT>
|
|
struct bitwise_or : _STD::binary_function<_TypeT, _TypeT, _TypeT>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT);
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
const second_argument_type &__y) const {
|
|
return __x | __y;
|
|
}
|
|
};
|
|
|
|
|
|
// extension: returns the bitwise and of the two arguments
|
|
template <class _TypeT>
|
|
struct bitwise_and : _STD::binary_function<_TypeT, _TypeT, _TypeT>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT);
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
const second_argument_type &__y) const {
|
|
return __x & __y;
|
|
}
|
|
};
|
|
|
|
|
|
// extension: returns the exclusive or (XOR) of the two arguments
|
|
template <class _TypeT>
|
|
struct exclusive_or : _STD::binary_function<_TypeT, _TypeT, _TypeT>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT);
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
const second_argument_type &__y) const {
|
|
return __x ^ __y;
|
|
}
|
|
};
|
|
|
|
|
|
// extension: returns the left argument shifted left by the right argument
|
|
template <class _TypeT>
|
|
struct shift_left : _STD::binary_function<_TypeT, _TypeT, _TypeT>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT);
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
const second_argument_type &__y) const {
|
|
return __x << __y;
|
|
}
|
|
};
|
|
|
|
|
|
// extension: returns the left argument shifted right by the right argument
|
|
template <class _TypeT>
|
|
struct shift_right : _STD::binary_function<_TypeT, _TypeT, _TypeT>
|
|
{
|
|
_RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT);
|
|
|
|
result_type operator() (const first_argument_type &__x,
|
|
const second_argument_type &__y) const {
|
|
return __x >> __y;
|
|
}
|
|
};
|
|
|
|
|
|
} // namespace __rw
|
|
|
|
|
|
#undef _RWSTD_UNARY_FUNCTION_TYPES
|
|
#undef _RWSTD_BINARY_FUNCTION_TYPES
|
|
|
|
|
|
#endif // _RWSTD_FUNCTIONAL_INCLUDED
|