1/* 2 * 3 * Copyright (c) 1994 4 * Hewlett-Packard Company 5 * 6 * Copyright (c) 1996-1998 7 * Silicon Graphics Computer Systems, Inc. 8 * 9 * Copyright (c) 1997 10 * Moscow Center for SPARC Technology 11 * 12 * Copyright (c) 1999 13 * Boris Fomitchev 14 * 15 * This material is provided "as is", with absolutely no warranty expressed 16 * or implied. Any use is at your own risk. 17 * 18 * Permission to use or copy this software for any purpose is hereby granted 19 * without fee, provided the above notices are retained on all copies. 20 * Permission to modify the code and to distribute modified code is granted, 21 * provided the above notices are retained, and a notice that the code was 22 * modified is included with the above copyright notice. 23 * 24 */ 25 26/* NOTE: This is an internal header file, included by other STL headers. 27 * You should not attempt to use it directly. 28 */ 29 30#ifndef _STLP_INTERNAL_FUNCTION_H 31#define _STLP_INTERNAL_FUNCTION_H 32 33#ifndef _STLP_TYPE_TRAITS_H 34# include <stl/type_traits.h> 35#endif 36 37#ifndef _STLP_INTERNAL_FUNCTION_BASE_H 38# include <stl/_function_base.h> 39#endif 40 41_STLP_BEGIN_NAMESPACE 42 43template <class _Tp> 44struct not_equal_to : public binary_function<_Tp, _Tp, bool> { 45 bool operator()(const _Tp& __x, const _Tp& __y) const { return __x != __y; } 46}; 47 48template <class _Tp> 49struct greater : public binary_function<_Tp, _Tp, bool> { 50 bool operator()(const _Tp& __x, const _Tp& __y) const { return __x > __y; } 51}; 52 53template <class _Tp> 54struct greater_equal : public binary_function<_Tp, _Tp, bool> { 55 bool operator()(const _Tp& __x, const _Tp& __y) const { return __x >= __y; } 56}; 57 58template <class _Tp> 59struct less_equal : public binary_function<_Tp, _Tp, bool> { 60 bool operator()(const _Tp& __x, const _Tp& __y) const { return __x <= __y; } 61}; 62 63template <class _Tp> 64struct divides : public binary_function<_Tp, _Tp, _Tp> { 65 _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x / __y; } 66}; 67 68template <class _Tp> 69struct modulus : public binary_function<_Tp, _Tp, _Tp> { 70 _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x % __y; } 71}; 72 73template <class _Tp> 74struct negate : public unary_function<_Tp, _Tp> { 75 _Tp operator()(const _Tp& __x) const { return -__x; } 76}; 77 78template <class _Tp> 79struct logical_and : public binary_function<_Tp, _Tp, bool> { 80 bool operator()(const _Tp& __x, const _Tp& __y) const { return __x && __y; } 81}; 82 83template <class _Tp> 84struct logical_or : public binary_function<_Tp, _Tp,bool> { 85 bool operator()(const _Tp& __x, const _Tp& __y) const { return __x || __y; } 86}; 87 88template <class _Tp> 89struct logical_not : public unary_function<_Tp, bool> { 90 bool operator()(const _Tp& __x) const { return !__x; } 91}; 92 93#if !defined (_STLP_NO_EXTENSIONS) 94// identity_element (not part of the C++ standard). 95template <class _Tp> inline _Tp identity_element(plus<_Tp>) { return _Tp(0); } 96template <class _Tp> inline _Tp identity_element(multiplies<_Tp>) { return _Tp(1); } 97#endif 98 99#if defined (_STLP_BASE_TYPEDEF_BUG) 100// this workaround is needed for SunPro 4.0.1 101// suggested by "Martin Abernethy" <gma@paston.co.uk>: 102 103// We have to introduce the XXary_predicate_aux structures in order to 104// access the argument and return types of predicate functions supplied 105// as type parameters. SUN C++ 4.0.1 compiler gives errors for template type parameters 106// of the form 'name1::name2', where name1 is itself a type parameter. 107template <class _Pair> 108struct __pair_aux : private _Pair { 109 typedef typename _Pair::first_type first_type; 110 typedef typename _Pair::second_type second_type; 111}; 112 113template <class _Operation> 114struct __unary_fun_aux : private _Operation { 115 typedef typename _Operation::argument_type argument_type; 116 typedef typename _Operation::result_type result_type; 117}; 118 119template <class _Operation> 120struct __binary_fun_aux : private _Operation { 121 typedef typename _Operation::first_argument_type first_argument_type; 122 typedef typename _Operation::second_argument_type second_argument_type; 123 typedef typename _Operation::result_type result_type; 124}; 125 126# define __UNARY_ARG(__Operation,__type) __unary_fun_aux<__Operation>::__type 127# define __BINARY_ARG(__Operation,__type) __binary_fun_aux<__Operation>::__type 128# define __PAIR_ARG(__Pair,__type) __pair_aux<__Pair>::__type 129#else 130# define __UNARY_ARG(__Operation,__type) __Operation::__type 131# define __BINARY_ARG(__Operation,__type) __Operation::__type 132# define __PAIR_ARG(__Pair,__type) __Pair::__type 133#endif 134 135template <class _Predicate> 136class unary_negate 137 : public unary_function<typename __UNARY_ARG(_Predicate, argument_type), bool> { 138 typedef unary_function<typename __UNARY_ARG(_Predicate, argument_type), bool> _Base; 139public: 140 typedef typename _Base::argument_type argument_type; 141private: 142 typedef typename __call_traits<argument_type>::const_param_type _ArgParamType; 143protected: 144 _Predicate _M_pred; 145public: 146 explicit unary_negate(const _Predicate& __x) : _M_pred(__x) {} 147 bool operator()(_ArgParamType __x) const { 148 return !_M_pred(__x); 149 } 150}; 151 152template <class _Predicate> 153inline unary_negate<_Predicate> 154not1(const _Predicate& __pred) { 155 return unary_negate<_Predicate>(__pred); 156} 157 158template <class _Predicate> 159class binary_negate 160 : public binary_function<typename __BINARY_ARG(_Predicate, first_argument_type), 161 typename __BINARY_ARG(_Predicate, second_argument_type), 162 bool> { 163 typedef binary_function<typename __BINARY_ARG(_Predicate, first_argument_type), 164 typename __BINARY_ARG(_Predicate, second_argument_type), 165 bool> _Base; 166public: 167 typedef typename _Base::first_argument_type first_argument_type; 168 typedef typename _Base::second_argument_type second_argument_type; 169private: 170 typedef typename __call_traits<first_argument_type>::const_param_type _FstArgParamType; 171 typedef typename __call_traits<second_argument_type>::const_param_type _SndArgParamType; 172protected: 173 _Predicate _M_pred; 174public: 175 explicit binary_negate(const _Predicate& __x) : _M_pred(__x) {} 176 bool operator()(_FstArgParamType __x, _SndArgParamType __y) const { 177 return !_M_pred(__x, __y); 178 } 179}; 180 181template <class _Predicate> 182inline binary_negate<_Predicate> 183not2(const _Predicate& __pred) { 184 return binary_negate<_Predicate>(__pred); 185} 186 187template <class _Operation> 188class binder1st : 189 public unary_function<typename __BINARY_ARG(_Operation, second_argument_type), 190 typename __BINARY_ARG(_Operation, result_type) > { 191 typedef unary_function<typename __BINARY_ARG(_Operation, second_argument_type), 192 typename __BINARY_ARG(_Operation, result_type) > _Base; 193public: 194 typedef typename _Base::argument_type argument_type; 195 typedef typename _Base::result_type result_type; 196private: 197 typedef typename __call_traits<argument_type>::param_type _ArgParamType; 198 typedef typename __call_traits<argument_type>::const_param_type _ConstArgParamType; 199 typedef typename __call_traits<typename _Operation::first_argument_type>::const_param_type _ValueParamType; 200protected: 201 //op is a Standard name (20.3.6.1), do no make it STLport naming convention compliant. 202 _Operation op; 203 typename _Operation::first_argument_type _M_value; 204public: 205 binder1st(const _Operation& __x, _ValueParamType __y) 206 : op(__x), _M_value(__y) {} 207 208 result_type operator()(_ConstArgParamType __x) const 209 { return op(_M_value, __x); } 210 // DR 109 Missing binders for non-const sequence elements 211 result_type operator()(_ArgParamType __x) const 212 { return op(_M_value, __x); } 213}; 214 215template <class _Operation, class _Tp> 216inline binder1st<_Operation> 217bind1st(const _Operation& __fn, const _Tp& __x) { 218 typedef typename _Operation::first_argument_type _Arg1_type; 219 return binder1st<_Operation>(__fn, _Arg1_type(__x)); 220} 221 222template <class _Operation> 223class binder2nd 224 : public unary_function<typename __BINARY_ARG(_Operation, first_argument_type), 225 typename __BINARY_ARG(_Operation, result_type)> { 226 typedef unary_function<typename __BINARY_ARG(_Operation, first_argument_type), 227 typename __BINARY_ARG(_Operation, result_type)> _Base; 228public: 229 typedef typename _Base::argument_type argument_type; 230 typedef typename _Base::result_type result_type; 231private: 232 typedef typename __call_traits<argument_type>::param_type _ArgParamType; 233 typedef typename __call_traits<argument_type>::const_param_type _ConstArgParamType; 234 typedef typename __call_traits<typename _Operation::second_argument_type>::const_param_type _ValueParamType; 235protected: 236 //op is a Standard name (20.3.6.3), do no make it STLport naming convention compliant. 237 _Operation op; 238 typename _Operation::second_argument_type value; 239public: 240 binder2nd(const _Operation& __x, _ValueParamType __y) 241 : op(__x), value(__y) {} 242 243 result_type operator()(_ConstArgParamType __x) const 244 { return op(__x, value); } 245 // DR 109 Missing binders for non-const sequence elements 246 result_type operator()(_ArgParamType __x) const 247 { return op(__x, value); } 248}; 249 250template <class _Operation, class _Tp> 251inline binder2nd<_Operation> 252bind2nd(const _Operation& __fn, const _Tp& __x) { 253 typedef typename _Operation::second_argument_type _Arg2_type; 254 return binder2nd<_Operation>(__fn, _Arg2_type(__x)); 255} 256 257#if !defined (_STLP_NO_EXTENSIONS) 258// unary_compose and binary_compose (extensions, not part of the standard). 259 260template <class _Operation1, class _Operation2> 261class unary_compose : 262 public unary_function<typename __UNARY_ARG(_Operation2, argument_type), 263 typename __UNARY_ARG(_Operation1, result_type)> { 264 typedef unary_function<typename __UNARY_ARG(_Operation2, argument_type), 265 typename __UNARY_ARG(_Operation1, result_type)> _Base; 266public: 267 typedef typename _Base::argument_type argument_type; 268 typedef typename _Base::result_type result_type; 269private: 270 typedef typename __call_traits<argument_type>::const_param_type _ArgParamType; 271protected: 272 _Operation1 _M_fn1; 273 _Operation2 _M_fn2; 274public: 275 unary_compose(const _Operation1& __x, const _Operation2& __y) 276 : _M_fn1(__x), _M_fn2(__y) {} 277 278 result_type operator()(_ArgParamType __x) const { 279 return _M_fn1(_M_fn2(__x)); 280 } 281}; 282 283template <class _Operation1, class _Operation2> 284inline unary_compose<_Operation1,_Operation2> 285compose1(const _Operation1& __fn1, const _Operation2& __fn2) { 286 return unary_compose<_Operation1,_Operation2>(__fn1, __fn2); 287} 288 289template <class _Operation1, class _Operation2, class _Operation3> 290class binary_compose : 291 public unary_function<typename __UNARY_ARG(_Operation2, argument_type), 292 typename __BINARY_ARG(_Operation1, result_type)> { 293 typedef unary_function<typename __UNARY_ARG(_Operation2, argument_type), 294 typename __BINARY_ARG(_Operation1, result_type)> _Base; 295public: 296 typedef typename _Base::argument_type argument_type; 297 typedef typename _Base::result_type result_type; 298private: 299 typedef typename __call_traits<argument_type>::const_param_type _ArgParamType; 300protected: 301 _Operation1 _M_fn1; 302 _Operation2 _M_fn2; 303 _Operation3 _M_fn3; 304public: 305 binary_compose(const _Operation1& __x, const _Operation2& __y, 306 const _Operation3& __z) 307 : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { } 308 309 result_type operator()(_ArgParamType __x) const { 310 return _M_fn1(_M_fn2(__x), _M_fn3(__x)); 311 } 312}; 313 314template <class _Operation1, class _Operation2, class _Operation3> 315inline binary_compose<_Operation1, _Operation2, _Operation3> 316compose2(const _Operation1& __fn1, const _Operation2& __fn2, 317 const _Operation3& __fn3) { 318 return binary_compose<_Operation1,_Operation2,_Operation3>(__fn1, __fn2, __fn3); 319} 320 321// identity is an extension: it is not part of the standard. 322template <class _Tp> struct identity : public _STLP_PRIV _Identity<_Tp> {}; 323// select1st and select2nd are extensions: they are not part of the standard. 324template <class _Pair> struct select1st : public _STLP_PRIV _Select1st<_Pair> {}; 325template <class _Pair> struct select2nd : public _STLP_PRIV _Select2nd<_Pair> {}; 326 327template <class _Arg1, class _Arg2> 328struct project1st : public _STLP_PRIV _Project1st<_Arg1, _Arg2> {}; 329 330template <class _Arg1, class _Arg2> 331struct project2nd : public _STLP_PRIV _Project2nd<_Arg1, _Arg2> {}; 332 333 334// constant_void_fun, constant_unary_fun, and constant_binary_fun are 335// extensions: they are not part of the standard. (The same, of course, 336// is true of the helper functions constant0, constant1, and constant2.) 337 338_STLP_MOVE_TO_PRIV_NAMESPACE 339 340template <class _Result> 341struct _Constant_void_fun { 342 typedef _Result result_type; 343 result_type _M_val; 344 345 _Constant_void_fun(const result_type& __v) : _M_val(__v) {} 346 const result_type& operator()() const { return _M_val; } 347}; 348 349_STLP_MOVE_TO_STD_NAMESPACE 350 351template <class _Result> 352struct constant_void_fun : public _STLP_PRIV _Constant_void_fun<_Result> { 353 constant_void_fun(const _Result& __v) 354 : _STLP_PRIV _Constant_void_fun<_Result>(__v) {} 355}; 356 357template <class _Result, _STLP_DFL_TMPL_PARAM( _Argument , _Result) > 358struct constant_unary_fun : public _STLP_PRIV _Constant_unary_fun<_Result, _Argument> { 359 constant_unary_fun(const _Result& __v) 360 : _STLP_PRIV _Constant_unary_fun<_Result, _Argument>(__v) {} 361}; 362 363template <class _Result, _STLP_DFL_TMPL_PARAM( _Arg1 , _Result), _STLP_DFL_TMPL_PARAM( _Arg2 , _Arg1) > 364struct constant_binary_fun 365 : public _STLP_PRIV _Constant_binary_fun<_Result, _Arg1, _Arg2> { 366 constant_binary_fun(const _Result& __v) 367 : _STLP_PRIV _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {} 368}; 369 370template <class _Result> 371inline constant_void_fun<_Result> constant0(const _Result& __val) { 372 return constant_void_fun<_Result>(__val); 373} 374 375template <class _Result> 376inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val) { 377 return constant_unary_fun<_Result,_Result>(__val); 378} 379 380template <class _Result> 381inline constant_binary_fun<_Result,_Result,_Result> 382constant2(const _Result& __val) { 383 return constant_binary_fun<_Result,_Result,_Result>(__val); 384} 385 386// subtractive_rng is an extension: it is not part of the standard. 387// Note: this code assumes that int is 32 bits. 388class subtractive_rng : public unary_function<_STLP_UINT32_T, _STLP_UINT32_T> { 389private: 390 _STLP_UINT32_T _M_table[55]; 391 _STLP_UINT32_T _M_index1; 392 _STLP_UINT32_T _M_index2; 393public: 394 _STLP_UINT32_T operator()(_STLP_UINT32_T __limit) { 395 _M_index1 = (_M_index1 + 1) % 55; 396 _M_index2 = (_M_index2 + 1) % 55; 397 _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2]; 398 return _M_table[_M_index1] % __limit; 399 } 400 401 void _M_initialize(_STLP_UINT32_T __seed) { 402 _STLP_UINT32_T __k = 1; 403 _M_table[54] = __seed; 404 _STLP_UINT32_T __i; 405 for (__i = 0; __i < 54; __i++) { 406 _STLP_UINT32_T __ii = (21 * (__i + 1) % 55) - 1; 407 _M_table[__ii] = __k; 408 __k = __seed - __k; 409 __seed = _M_table[__ii]; 410 } 411 for (int __loop = 0; __loop < 4; __loop++) { 412 for (__i = 0; __i < 55; __i++) 413 _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55]; 414 } 415 _M_index1 = 0; 416 _M_index2 = 31; 417 } 418 419 subtractive_rng(unsigned int __seed) { _M_initialize(__seed); } 420 subtractive_rng() { _M_initialize(161803398ul); } 421}; 422 423#endif /* _STLP_NO_EXTENSIONS */ 424 425_STLP_END_NAMESPACE 426 427#include <stl/_function_adaptors.h> 428 429#endif /* _STLP_INTERNAL_FUNCTION_H */ 430 431// Local Variables: 432// mode:C++ 433// End: 434