include/c++/stl/stl/_function.h

   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
  43 template <class _Tp>
  44 struct not_equal_to : public binary_function<_Tp, _Tp, bool> {
  45   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x != __y; }
  46 };
  47
  48 template <class _Tp>
  49 struct greater : public binary_function<_Tp, _Tp, bool> {
  50   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x > __y; }
  51 };
  52
  53 template <class _Tp>
  54 struct greater_equal : public binary_function<_Tp, _Tp, bool> {
  55   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x >= __y; }
  56 };
  57
  58 template <class _Tp>
  59 struct less_equal : public binary_function<_Tp, _Tp, bool> {
  60   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x <= __y; }
  61 };
  62
  63 template <class _Tp>
  64 struct divides : public binary_function<_Tp, _Tp, _Tp> {
  65   _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x / __y; }
  66 };
  67
  68 template <class _Tp>
  69 struct modulus : public binary_function<_Tp, _Tp, _Tp> {
  70   _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x % __y; }
  71 };
  72
  73 template <class _Tp>
  74 struct negate : public unary_function<_Tp, _Tp> {
  75   _Tp operator()(const _Tp& __x) const { return -__x; }
  76 };
  77
  78 template <class _Tp>
  79 struct logical_and : public binary_function<_Tp, _Tp, bool> {
  80   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x && __y; }
  81 };
  82
  83 template <class _Tp>
  84 struct logical_or : public binary_function<_Tp, _Tp,bool> {
  85   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x || __y; }
  86 };
  87
  88 template <class _Tp>
  89 struct 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).
  95 template <class _Tp> inline _Tp identity_element(plus<_Tp>) {  return _Tp(0); }
  96 template <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.
 107 template <class _Pair>
 108 struct __pair_aux : private _Pair {
 109   typedef typename _Pair::first_type first_type;
 110   typedef typename _Pair::second_type second_type;
 111 };
 112
 113 template <class _Operation>
 114 struct __unary_fun_aux : private _Operation {
 115   typedef typename _Operation::argument_type argument_type;
 116   typedef typename _Operation::result_type result_type;
 117 };
 118
 119 template <class _Operation>
 120 struct __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
 135 template <class _Predicate>
 136 class 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;
 139 public:
 140   typedef typename _Base::argument_type argument_type;
 141 private:
 142   typedef typename __call_traits<argument_type>::param_type _ArgParamType;
 143 protected:
 144   _Predicate _M_pred;
 145 public:
 146   explicit unary_negate(const _Predicate& __x) : _M_pred(__x) {}
 147   bool operator()(_ArgParamType __x) const {
 148     return !_M_pred(__x);
 149   }
 150 };
 151
 152 template <class _Predicate>
 153 inline unary_negate<_Predicate>
 154 not1(const _Predicate& __pred) {
 155   return unary_negate<_Predicate>(__pred);
 156 }
 157
 158 template <class _Predicate>
 159 class 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;
 166 public:
 167   typedef typename _Base::first_argument_type first_argument_type;
 168   typedef typename _Base::second_argument_type second_argument_type;
 169 private:
 170   typedef typename __call_traits<first_argument_type>::param_type _FstArgParamType;
 171   typedef typename __call_traits<second_argument_type>::param_type _SndArgParamType;
 172 protected:
 173   _Predicate _M_pred;
 174 public:
 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
 181 template <class _Predicate>
 182 inline binary_negate<_Predicate>
 183 not2(const _Predicate& __pred) {
 184   return binary_negate<_Predicate>(__pred);
 185 }
 186
 187 template <class _Operation>
 188 class 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;
 193 public:
 194   typedef typename _Base::argument_type argument_type;
 195   typedef typename _Base::result_type result_type;
 196 private:
 197   typedef typename __call_traits<argument_type>::param_type _ArgParamType;
 198   typedef typename __call_traits<typename _Operation::first_argument_type>::param_type _ValueParamType;
 199 protected:
 200   //op is a Standard name (20.3.6.1), do no make it STLport naming convention compliant.
 201   _Operation op;
 202   typename _Operation::first_argument_type _M_value;
 203 public:
 204   binder1st(const _Operation& __x, _ValueParamType __y)
 205       : op(__x), _M_value(__y) {}
 206
 207   result_type operator()(_ArgParamType __x) const {
 208     return op(_M_value, __x);
 209   }
 210 };
 211
 212 template <class _Operation, class _Tp>
 213 inline binder1st<_Operation>
 214 bind1st(const _Operation& __fn, const _Tp& __x) {
 215   typedef typename _Operation::first_argument_type _Arg1_type;
 216   return binder1st<_Operation>(__fn, _Arg1_type(__x));
 217 }
 218
 219 template <class _Operation>
 220 class binder2nd
 221   : public unary_function<typename __BINARY_ARG(_Operation, first_argument_type),
 222                           typename __BINARY_ARG(_Operation, result_type)> {
 223   typedef unary_function<typename __BINARY_ARG(_Operation, first_argument_type),
 224                          typename __BINARY_ARG(_Operation, result_type)> _Base;
 225 public:
 226   typedef typename _Base::argument_type argument_type;
 227   typedef typename _Base::result_type result_type;
 228 private:
 229   typedef typename __call_traits<argument_type>::param_type _ArgParamType;
 230   typedef typename __call_traits<typename _Operation::second_argument_type>::param_type _ValueParamType;
 231 protected:
 232   //op is a Standard name (20.3.6.3), do no make it STLport naming convention compliant.
 233   _Operation op;
 234   typename _Operation::second_argument_type value;
 235 public:
 236   binder2nd(const _Operation& __x, _ValueParamType __y)
 237       : op(__x), value(__y) {}
 238
 239   result_type operator()(_ArgParamType __x) const {
 240     return op(__x, value);
 241   }
 242 };
 243
 244 template <class _Operation, class _Tp>
 245 inline binder2nd<_Operation>
 246 bind2nd(const _Operation& __fn, const _Tp& __x) {
 247   typedef typename _Operation::second_argument_type _Arg2_type;
 248   return binder2nd<_Operation>(__fn, _Arg2_type(__x));
 249 }
 250
 251 #if !defined (_STLP_NO_EXTENSIONS)
 252 // unary_compose and binary_compose (extensions, not part of the standard).
 253
 254 template <class _Operation1, class _Operation2>
 255 class unary_compose :
 256   public unary_function<typename __UNARY_ARG(_Operation2, argument_type),
 257                         typename __UNARY_ARG(_Operation1, result_type)> {
 258   typedef unary_function<typename __UNARY_ARG(_Operation2, argument_type),
 259                          typename __UNARY_ARG(_Operation1, result_type)> _Base;
 260 public:
 261   typedef typename _Base::argument_type argument_type;
 262   typedef typename _Base::result_type result_type;
 263 private:
 264   typedef typename __call_traits<argument_type>::param_type _ArgParamType;
 265 protected:
 266   _Operation1 _M_fn1;
 267   _Operation2 _M_fn2;
 268 public:
 269   unary_compose(const _Operation1& __x, const _Operation2& __y)
 270     : _M_fn1(__x), _M_fn2(__y) {}
 271
 272   result_type operator()(_ArgParamType __x) const {
 273     return _M_fn1(_M_fn2(__x));
 274   }
 275 };
 276
 277 template <class _Operation1, class _Operation2>
 278 inline unary_compose<_Operation1,_Operation2>
 279 compose1(const _Operation1& __fn1, const _Operation2& __fn2) {
 280   return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);
 281 }
 282
 283 template <class _Operation1, class _Operation2, class _Operation3>
 284 class binary_compose :
 285     public unary_function<typename __UNARY_ARG(_Operation2, argument_type),
 286                           typename __BINARY_ARG(_Operation1, result_type)> {
 287   typedef unary_function<typename __UNARY_ARG(_Operation2, argument_type),
 288                          typename __BINARY_ARG(_Operation1, result_type)> _Base;
 289 public:
 290   typedef typename _Base::argument_type argument_type;
 291   typedef typename _Base::result_type result_type;
 292 private:
 293   typedef typename __call_traits<argument_type>::param_type _ArgParamType;
 294 protected:
 295   _Operation1 _M_fn1;
 296   _Operation2 _M_fn2;
 297   _Operation3 _M_fn3;
 298 public:
 299   binary_compose(const _Operation1& __x, const _Operation2& __y,
 300                  const _Operation3& __z)
 301     : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { }
 302
 303   result_type operator()(_ArgParamType __x) const {
 304     return _M_fn1(_M_fn2(__x), _M_fn3(__x));
 305   }
 306 };
 307
 308 template <class _Operation1, class _Operation2, class _Operation3>
 309 inline binary_compose<_Operation1, _Operation2, _Operation3>
 310 compose2(const _Operation1& __fn1, const _Operation2& __fn2,
 311          const _Operation3& __fn3) {
 312   return binary_compose<_Operation1,_Operation2,_Operation3>(__fn1, __fn2, __fn3);
 313 }
 314
 315 // identity is an extension: it is not part of the standard.
 316 template <class _Tp> struct identity : public _STLP_PRIV _Identity<_Tp> {};
 317 // select1st and select2nd are extensions: they are not part of the standard.
 318 template <class _Pair> struct select1st : public _STLP_PRIV _Select1st<_Pair> {};
 319 template <class _Pair> struct select2nd : public _STLP_PRIV _Select2nd<_Pair> {};
 320
 321 template <class _Arg1, class _Arg2>
 322 struct project1st : public _STLP_PRIV _Project1st<_Arg1, _Arg2> {};
 323
 324 template <class _Arg1, class _Arg2>
 325 struct project2nd : public _STLP_PRIV _Project2nd<_Arg1, _Arg2> {};
 326
 327
 328 // constant_void_fun, constant_unary_fun, and constant_binary_fun are
 329 // extensions: they are not part of the standard.  (The same, of course,
 330 // is true of the helper functions constant0, constant1, and constant2.)
 331
 332 _STLP_MOVE_TO_PRIV_NAMESPACE
 333
 334 template <class _Result>
 335 struct _Constant_void_fun {
 336   typedef _Result result_type;
 337   result_type _M_val;
 338
 339   _Constant_void_fun(const result_type& __v) : _M_val(__v) {}
 340   const result_type& operator()() const { return _M_val; }
 341 };
 342
 343 _STLP_MOVE_TO_STD_NAMESPACE
 344
 345 template <class _Result>
 346 struct constant_void_fun : public _STLP_PRIV _Constant_void_fun<_Result> {
 347   constant_void_fun(const _Result& __v)
 348     : _STLP_PRIV _Constant_void_fun<_Result>(__v) {}
 349 };
 350
 351 template <class _Result, _STLP_DFL_TMPL_PARAM( _Argument , _Result) >
 352 struct constant_unary_fun : public _STLP_PRIV _Constant_unary_fun<_Result, _Argument> {
 353   constant_unary_fun(const _Result& __v)
 354     : _STLP_PRIV _Constant_unary_fun<_Result, _Argument>(__v) {}
 355 };
 356
 357 template <class _Result, _STLP_DFL_TMPL_PARAM( _Arg1 , _Result), _STLP_DFL_TMPL_PARAM( _Arg2 , _Arg1) >
 358 struct constant_binary_fun
 359   : public _STLP_PRIV _Constant_binary_fun<_Result, _Arg1, _Arg2> {
 360   constant_binary_fun(const _Result& __v)
 361     : _STLP_PRIV _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {}
 362 };
 363
 364 template <class _Result>
 365 inline constant_void_fun<_Result> constant0(const _Result& __val) {
 366   return constant_void_fun<_Result>(__val);
 367 }
 368
 369 template <class _Result>
 370 inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val) {
 371   return constant_unary_fun<_Result,_Result>(__val);
 372 }
 373
 374 template <class _Result>
 375 inline constant_binary_fun<_Result,_Result,_Result>
 376 constant2(const _Result& __val) {
 377   return constant_binary_fun<_Result,_Result,_Result>(__val);
 378 }
 379
 380 // subtractive_rng is an extension: it is not part of the standard.
 381 // Note: this code assumes that int is 32 bits.
 382 class subtractive_rng : public unary_function<_STLP_UINT32_T, _STLP_UINT32_T> {
 383 private:
 384   _STLP_UINT32_T _M_table[55];
 385   _STLP_UINT32_T _M_index1;
 386   _STLP_UINT32_T _M_index2;
 387 public:
 388   _STLP_UINT32_T operator()(_STLP_UINT32_T __limit) {
 389     _M_index1 = (_M_index1 + 1) % 55;
 390     _M_index2 = (_M_index2 + 1) % 55;
 391     _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2];
 392     return _M_table[_M_index1] % __limit;
 393   }
 394
 395   void _M_initialize(_STLP_UINT32_T __seed) {
 396     _STLP_UINT32_T __k = 1;
 397     _M_table[54] = __seed;
 398     _STLP_UINT32_T __i;
 399     for (__i = 0; __i < 54; __i++) {
 400         _STLP_UINT32_T __ii = (21 * (__i + 1) % 55) - 1;
 401         _M_table[__ii] = __k;
 402         __k = __seed - __k;
 403         __seed = _M_table[__ii];
 404     }
 405     for (int __loop = 0; __loop < 4; __loop++) {
 406         for (__i = 0; __i < 55; __i++)
 407             _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55];
 408     }
 409     _M_index1 = 0;
 410     _M_index2 = 31;
 411   }
 412
 413   subtractive_rng(unsigned int __seed) { _M_initialize(__seed); }
 414   subtractive_rng() { _M_initialize(161803398ul); }
 415 };
 416
 417 #endif /* _STLP_NO_EXTENSIONS */
 418
 419 _STLP_END_NAMESPACE
 420
 421 #include <stl/_function_adaptors.h>
 422
 423 #endif /* _STLP_INTERNAL_FUNCTION_H */
 424
 425 // Local Variables:
 426 // mode:C++
 427 // End: