From 357744cd54478d5d74cb52cd1459eb7c26192abd Mon Sep 17 00:00:00 2001 From: phil Date: Sat, 9 Mar 1996 00:00:51 +0000 Subject: Import of libg++-2.7.1. --- gnu/lib/libg++/libstdc++/stl/function.h | 282 ++++++++++++++++++++++++++++++++ 1 file changed, 282 insertions(+) create mode 100644 gnu/lib/libg++/libstdc++/stl/function.h (limited to 'gnu/lib/libg++/libstdc++/stl/function.h') diff --git a/gnu/lib/libg++/libstdc++/stl/function.h b/gnu/lib/libg++/libstdc++/stl/function.h new file mode 100644 index 00000000000..46fe55569bb --- /dev/null +++ b/gnu/lib/libg++/libstdc++/stl/function.h @@ -0,0 +1,282 @@ +/* + * + * 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. + * + */ + +#ifndef FUNCTION_H +#define FUNCTION_H + +#ifndef __GNUG__ +#include +#endif + +template +inline bool operator!=(const T1& x, const T2& y) { + return !(x == y); +} + +template +inline bool operator>(const T1& x, const T2& y) { + return y < x; +} + +template +inline bool operator<=(const T1& x, const T2& y) { + return !(y < x); +} + +template +inline bool operator>=(const T1& x, const T2& y) { + return !(x < y); +} + +template +struct unary_function { + typedef Arg argument_type; + typedef Result result_type; +}; + +template +struct binary_function { + typedef Arg1 first_argument_type; + typedef Arg2 second_argument_type; + typedef Result result_type; +}; + +template +struct plus : binary_function { + T operator()(const T& x, const T& y) const { return x + y; } +}; + +template +struct minus : binary_function { + T operator()(const T& x, const T& y) const { return x - y; } +}; + +template +struct times : binary_function { + T operator()(const T& x, const T& y) const { return x * y; } +}; + +template +struct divides : binary_function { + T operator()(const T& x, const T& y) const { return x / y; } +}; + +template +#ifdef __GNU__ +struct modulus { + typedef T first_argument_type; + typedef T second_argument_type; + typedef T result_type; + T operator()(const T& x, const T& y) const { return x % y; } +}; +#else +struct modulus : binary_function { + T operator()(const T& x, const T& y) const { return x % y; } +}; +#endif + +template +struct negate : unary_function { + T operator()(const T& x) const { return -x; } +}; + +template +struct equal_to : binary_function { + bool operator()(const T& x, const T& y) const { return x == y; } +}; + +template +struct not_equal_to : binary_function { + bool operator()(const T& x, const T& y) const { return x != y; } +}; + +template +struct greater : binary_function { + bool operator()(const T& x, const T& y) const { return x > y; } +}; + +template +struct less : binary_function { + bool operator()(const T& x, const T& y) const { return x < y; } +}; + +template +struct greater_equal : binary_function { + bool operator()(const T& x, const T& y) const { return x >= y; } +}; + +template +struct less_equal : binary_function { + bool operator()(const T& x, const T& y) const { return x <= y; } +}; + +template +struct logical_and : binary_function { + bool operator()(const T& x, const T& y) const { return x && y; } +}; + +template +struct logical_or : binary_function { + bool operator()(const T& x, const T& y) const { return x || y; } +}; + +template +struct logical_not : unary_function { + bool operator()(const T& x) const { return !x; } +}; + +template +class unary_negate : public unary_function { +protected: + Predicate pred; +public: + unary_negate(const Predicate& x) : pred(x) {} + bool operator()(const argument_type& x) const { return !pred(x); } +}; + +template +unary_negate not1(const Predicate& pred) { + return unary_negate(pred); +} + +template +class binary_negate + : public binary_function { +protected: + Predicate pred; +public: + binary_negate(const Predicate& x) : pred(x) {} + bool operator()(const first_argument_type& x, + const second_argument_type& y) const { + return !pred(x, y); + } +}; + +template +binary_negate not2(const Predicate& pred) { + return binary_negate(pred); +} + +template +class binder1st : public unary_function { +protected: + Operation op; + Operation::first_argument_type value; +public: + binder1st(const Operation& x, const Operation::first_argument_type& y) + : op(x), value(y) {} + result_type operator()(const argument_type& x) const { + return op(value, x); + } +}; + +template +binder1st bind1st(const Operation& op, const T& x) { + return binder1st(op, Operation::first_argument_type(x)); +} + +template +class binder2nd : public unary_function { +protected: + Operation op; + Operation::second_argument_type value; +public: + binder2nd(const Operation& x, const Operation::second_argument_type& y) + : op(x), value(y) {} + result_type operator()(const argument_type& x) const { + return op(x, value); + } +}; + +template +binder2nd bind2nd(const Operation& op, const T& x) { + return binder2nd(op, Operation::second_argument_type(x)); +} + +template +class unary_compose : public unary_function { +protected: + Operation1 op1; + Operation2 op2; +public: + unary_compose(const Operation1& x, const Operation2& y) : op1(x), op2(y) {} + result_type operator()(const argument_type& x) const { + return op1(op2(x)); + } +}; + +template +unary_compose compose1(const Operation1& op1, + const Operation2& op2) { + return unary_compose(op1, op2); +} + +template +class binary_compose : public unary_function { +protected: + Operation1 op1; + Operation2 op2; + Operation3 op3; +public: + binary_compose(const Operation1& x, const Operation2& y, + const Operation3& z) : op1(x), op2(y), op3(z) { } + result_type operator()(const argument_type& x) const { + return op1(op2(x), op3(x)); + } +}; + +template +binary_compose +compose2(const Operation1& op1, const Operation2& op2, const Operation3& op3) { + return binary_compose(op1, op2, op3); +} + +template +class pointer_to_unary_function : public unary_function { +protected: + Result (*ptr)(Arg); +public: + pointer_to_unary_function() {} + pointer_to_unary_function(Result (*x)(Arg)) : ptr(x) {} + Result operator()(Arg x) const { return ptr(x); } +}; + +template +pointer_to_unary_function ptr_fun(Result (*x)(Arg)) { + return pointer_to_unary_function(x); +} + +template +class pointer_to_binary_function : public binary_function { +protected: + Result (*ptr)(Arg1, Arg2); +public: + pointer_to_binary_function() {} + pointer_to_binary_function(Result (*x)(Arg1, Arg2)) : ptr(x) {} + Result operator()(Arg1 x, Arg2 y) const { return ptr(x, y); } +}; + +template +pointer_to_binary_function +ptr_fun(Result (*x)(Arg1, Arg2)) { + return pointer_to_binary_function(x); +} + +#endif -- cgit