reactos/include/c++/stlport/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>::const_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>::const_param_type _FstArgParamType;
 171   typedef typename __call_traits<second_argument_type>::const_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<argument_type>::const_param_type _ConstArgParamType;
 199   typedef typename __call_traits<typename _Operation::first_argument_type>::const_param_type _ValueParamType;
 200 protected:
 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;
 204 public:
 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
 215 template <class _Operation, class _Tp>
 216 inline binder1st<_Operation>
 217 bind1st(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
 222 template <class _Operation>
 223 class 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;
 228 public:
 229   typedef typename _Base::argument_type argument_type;
 230   typedef typename _Base::result_type result_type;
 231 private:
 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;
 235 protected:
 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;
 239 public:
 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
 250 template <class _Operation, class _Tp>
 251 inline binder2nd<_Operation>
 252 bind2nd(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
 260 template <class _Operation1, class _Operation2>
 261 class 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;
 266 public:
 267   typedef typename _Base::argument_type argument_type;
 268   typedef typename _Base::result_type result_type;
 269 private:
 270   typedef typename __call_traits<argument_type>::const_param_type _ArgParamType;
 271 protected:
 272   _Operation1 _M_fn1;
 273   _Operation2 _M_fn2;
 274 public:
 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
 283 template <class _Operation1, class _Operation2>
 284 inline unary_compose<_Operation1,_Operation2>
 285 compose1(const _Operation1& __fn1, const _Operation2& __fn2) {
 286   return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);
 287 }
 288
 289 template <class _Operation1, class _Operation2, class _Operation3>
 290 class 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;
 295 public:
 296   typedef typename _Base::argument_type argument_type;
 297   typedef typename _Base::result_type result_type;
 298 private:
 299   typedef typename __call_traits<argument_type>::const_param_type _ArgParamType;
 300 protected:
 301   _Operation1 _M_fn1;
 302   _Operation2 _M_fn2;
 303   _Operation3 _M_fn3;
 304 public:
 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
 314 template <class _Operation1, class _Operation2, class _Operation3>
 315 inline binary_compose<_Operation1, _Operation2, _Operation3>
 316 compose2(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.
 322 template <class _Tp> struct identity : public _STLP_PRIV _Identity<_Tp> {};
 323 // select1st and select2nd are extensions: they are not part of the standard.
 324 template <class _Pair> struct select1st : public _STLP_PRIV _Select1st<_Pair> {};
 325 template <class _Pair> struct select2nd : public _STLP_PRIV _Select2nd<_Pair> {};
 326
 327 template <class _Arg1, class _Arg2>
 328 struct project1st : public _STLP_PRIV _Project1st<_Arg1, _Arg2> {};
 329
 330 template <class _Arg1, class _Arg2>
 331 struct 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
 340 template <class _Result>
 341 struct _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
 351 template <class _Result>
 352 struct 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
 357 template <class _Result, _STLP_DFL_TMPL_PARAM( _Argument , _Result) >
 358 struct 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
 363 template <class _Result, _STLP_DFL_TMPL_PARAM( _Arg1 , _Result), _STLP_DFL_TMPL_PARAM( _Arg2 , _Arg1) >
 364 struct 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
 370 template <class _Result>
 371 inline constant_void_fun<_Result> constant0(const _Result& __val) {
 372   return constant_void_fun<_Result>(__val);
 373 }
 374
 375 template <class _Result>
 376 inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val) {
 377   return constant_unary_fun<_Result,_Result>(__val);
 378 }
 379
 380 template <class _Result>
 381 inline constant_binary_fun<_Result,_Result,_Result>
 382 constant2(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.
 388 class subtractive_rng : public unary_function<_STLP_UINT32_T, _STLP_UINT32_T> {
 389 private:
 390   _STLP_UINT32_T _M_table[55];
 391   _STLP_UINT32_T _M_index1;
 392   _STLP_UINT32_T _M_index2;
 393 public:
 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: