source: svn/newcon3bcm2_21bu/toolchain/include/c++/3.4.2/ext/functional

// Functional extensions -*- C++ -*-



// Copyright (C) 2002 Free Software Foundation, Inc.

//

// This file is part of the GNU ISO C++ Library.  This library is free

// software; you can redistribute it and/or modify it under the

// terms of the GNU General Public License as published by the

// Free Software Foundation; either version 2, or (at your option)

// any later version.



// This library is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.



// You should have received a copy of the GNU General Public License along

// with this library; see the file COPYING.  If not, write to the Free

// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,

// USA.



// As a special exception, you may use this file as part of a free software

// library without restriction.  Specifically, if other files instantiate

// templates or use macros or inline functions from this file, or you compile

// this file and link it with other files to produce an executable, this

// file does not by itself cause the resulting executable to be covered by

// the GNU General Public License.  This exception does not however

// invalidate any other reasons why the executable file might be covered by

// the GNU General Public License.



/*

 *

 * 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.

 *

 *

 * Copyright (c) 1996

 * Silicon Graphics Computer Systems, Inc.

 *

 * 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.  Silicon Graphics makes no

 * representations about the suitability of this software for any

 * purpose.  It is provided "as is" without express or implied warranty.

 */



/** @file ext/functional

 *  This file is a GNU extension to the Standard C++ Library (possibly

 *  containing extensions from the HP/SGI STL subset).  You should only

 *  include this header if you are using GCC 3 or later.

 */



#ifndef _EXT_FUNCTIONAL

#define _EXT_FUNCTIONAL 1



#pragma GCC system_header



#include <functional>



namespace __gnu_cxx

{

using std::unary_function;

using std::binary_function;

using std::mem_fun1_t;

using std::const_mem_fun1_t;

using std::mem_fun1_ref_t;

using std::const_mem_fun1_ref_t;



/** The @c identity_element functions are not part of the C++ standard; SGI

 *  provided them as an extension.  Its argument is an operation, and its

 *  return value is the identity element for that operation.  It is overloaded

 *  for addition and multiplication, and you can overload it for your own

 *  nefarious operations.

 *

 *  @addtogroup SGIextensions

 *  @{

*/

/// An \link SGIextensions SGI extension \endlink.

template <class _Tp> inline _Tp identity_element(std::plus<_Tp>) {

  return _Tp(0);

}

/// An \link SGIextensions SGI extension \endlink.

template <class _Tp> inline _Tp identity_element(std::multiplies<_Tp>) {

  return _Tp(1);

}

/** @}  */



/** As an extension to the binders, SGI provided composition functors and

 *  wrapper functions to aid in their creation.  The @c unary_compose

 *  functor is constructed from two functions/functors, @c f and @c g.

 *  Calling @c operator() with a single argument @c x returns @c f(g(x)).

 *  The function @c compose1 takes the two functions and constructs a

 *  @c unary_compose variable for you.

 *

 *  @c binary_compose is constructed from three functors, @c f, @c g1,

 *  and @c g2.  Its @c operator() returns @c f(g1(x),g2(x)).  The function

 *  @compose2 takes f, g1, and g2, and constructs the @c binary_compose

 *  instance for you.  For example, if @c f returns an int, then

 *  \code

 *  int answer = (compose2(f,g1,g2))(x);

 *  \endcode

 *  is equivalent to

 *  \code

 *  int temp1 = g1(x);

 *  int temp2 = g2(x);

 *  int answer = f(temp1,temp2);

 *  \endcode

 *  But the first form is more compact, and can be passed around as a

 *  functor to other algorithms.

 *

 *  @addtogroup SGIextensions

 *  @{

*/

/// An \link SGIextensions SGI extension \endlink.

template <class _Operation1, class _Operation2>

class unary_compose

  : public unary_function<typename _Operation2::argument_type,

                       typename _Operation1::result_type>

{

protected:

  _Operation1 _M_fn1;

  _Operation2 _M_fn2;

public:

  unary_compose(const _Operation1& __x, const _Operation2& __y)

    : _M_fn1(__x), _M_fn2(__y) {}

  typename _Operation1::result_type

  operator()(const typename _Operation2::argument_type& __x) const {

    return _M_fn1(_M_fn2(__x));

  }

};



/// An \link SGIextensions SGI extension \endlink.

template <class _Operation1, class _Operation2>

inline unary_compose<_Operation1,_Operation2>

compose1(const _Operation1& __fn1, const _Operation2& __fn2)

{

  return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);

}



/// An \link SGIextensions SGI extension \endlink.

template <class _Operation1, class _Operation2, class _Operation3>

class binary_compose

  : public unary_function<typename _Operation2::argument_type,

                          typename _Operation1::result_type> {

protected:

  _Operation1 _M_fn1;

  _Operation2 _M_fn2;

  _Operation3 _M_fn3;

public:

  binary_compose(const _Operation1& __x, const _Operation2& __y,

                 const _Operation3& __z)

    : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { }

  typename _Operation1::result_type

  operator()(const typename _Operation2::argument_type& __x) const {

    return _M_fn1(_M_fn2(__x), _M_fn3(__x));

  }

};



/// An \link SGIextensions SGI extension \endlink.

template <class _Operation1, class _Operation2, class _Operation3>

inline binary_compose<_Operation1, _Operation2, _Operation3>

compose2(const _Operation1& __fn1, const _Operation2& __fn2,

         const _Operation3& __fn3)

{

  return binary_compose<_Operation1,_Operation2,_Operation3>

    (__fn1, __fn2, __fn3);

}

/** @}  */



/** As an extension, SGI provided a functor called @c identity.  When a

 *  functor is required but no operations are desired, this can be used as a

 *  pass-through.  Its @c operator() returns its argument unchanged.

 *

 *  @addtogroup SGIextensions

*/

template <class _Tp> struct identity : public std::_Identity<_Tp> {};



/** @c select1st and @c select2nd are extensions provided by SGI.  Their

 *  @c operator()s

 *  take a @c std::pair as an argument, and return either the first member

 *  or the second member, respectively.  They can be used (especially with

 *  the composition functors) to "strip" data from a sequence before

 *  performing the remainder of an algorithm.

 *

 *  @addtogroup SGIextensions

 *  @{

*/

/// An \link SGIextensions SGI extension \endlink.

template <class _Pair> struct select1st : public std::_Select1st<_Pair> {};

/// An \link SGIextensions SGI extension \endlink.

template <class _Pair> struct select2nd : public std::_Select2nd<_Pair> {};

/** @}  */



// extension documented next

template <class _Arg1, class _Arg2>

struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> {

  _Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; }

};



template <class _Arg1, class _Arg2>

struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> {

  _Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; }

};



/** The @c operator() of the @c project1st functor takes two arbitrary

 *  arguments and returns the first one, while @c project2nd returns the

 *  second one.  They are extensions provided by SGI.

 *

 *  @addtogroup SGIextensions

 *  @{

*/



/// An \link SGIextensions SGI extension \endlink.

template <class _Arg1, class _Arg2>

struct project1st : public _Project1st<_Arg1, _Arg2> {};



/// An \link SGIextensions SGI extension \endlink.

template <class _Arg1, class _Arg2>

struct project2nd : public _Project2nd<_Arg1, _Arg2> {};

/** @}  */



// extension documented next

template <class _Result>

struct _Constant_void_fun {

  typedef _Result result_type;

  result_type _M_val;



  _Constant_void_fun(const result_type& __v) : _M_val(__v) {}

  const result_type& operator()() const { return _M_val; }

};



template <class _Result, class _Argument>

struct _Constant_unary_fun {

  typedef _Argument argument_type;

  typedef  _Result  result_type;

  result_type _M_val;



  _Constant_unary_fun(const result_type& __v) : _M_val(__v) {}

  const result_type& operator()(const _Argument&) const { return _M_val; }

};



template <class _Result, class _Arg1, class _Arg2>

struct _Constant_binary_fun {

  typedef  _Arg1   first_argument_type;

  typedef  _Arg2   second_argument_type;

  typedef  _Result result_type;

  _Result _M_val;



  _Constant_binary_fun(const _Result& __v) : _M_val(__v) {}

  const result_type& operator()(const _Arg1&, const _Arg2&) const {

    return _M_val;

  }

};



/** These three functors are each constructed from a single arbitrary

 *  variable/value.  Later, their @c operator()s completely ignore any

 *  arguments passed, and return the stored value.

 *  - @c constant_void_fun's @c operator() takes no arguments

 *  - @c constant_unary_fun's @c operator() takes one argument (ignored)

 *  - @c constant_binary_fun's @c operator() takes two arguments (ignored)

 *

 *  The helper creator functions @c constant0, @c constant1, and

 *  @c constant2 each take a "result" argument and construct variables of

 *  the appropriate functor type.

 *

 *  @addtogroup SGIextensions

 *  @{

*/

/// An \link SGIextensions SGI extension \endlink.

template <class _Result>

struct constant_void_fun : public _Constant_void_fun<_Result> {

  constant_void_fun(const _Result& __v) : _Constant_void_fun<_Result>(__v) {}

};



/// An \link SGIextensions SGI extension \endlink.

template <class _Result,

          class _Argument = _Result>

struct constant_unary_fun : public _Constant_unary_fun<_Result, _Argument>

{

  constant_unary_fun(const _Result& __v)

    : _Constant_unary_fun<_Result, _Argument>(__v) {}

};



/// An \link SGIextensions SGI extension \endlink.

template <class _Result,

          class _Arg1 = _Result,

          class _Arg2 = _Arg1>

struct constant_binary_fun

  : public _Constant_binary_fun<_Result, _Arg1, _Arg2>

{

  constant_binary_fun(const _Result& __v)

    : _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {}

};



/// An \link SGIextensions SGI extension \endlink.

template <class _Result>

inline constant_void_fun<_Result> constant0(const _Result& __val)

{

  return constant_void_fun<_Result>(__val);

}



/// An \link SGIextensions SGI extension \endlink.

template <class _Result>

inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val)

{

  return constant_unary_fun<_Result,_Result>(__val);

}



/// An \link SGIextensions SGI extension \endlink.

template <class _Result>

inline constant_binary_fun<_Result,_Result,_Result>

constant2(const _Result& __val)

{

  return constant_binary_fun<_Result,_Result,_Result>(__val);

}

/** @}  */



/** The @c subtractive_rng class is documented on

 *  <a href="http://www.sgi.com/tech/stl/">SGI's site</a>.

 *  Note that this code assumes that @c int is 32 bits.

 *

 *  @ingroup SGIextensions

*/

class subtractive_rng : public unary_function<unsigned int, unsigned int> {

private:

  unsigned int _M_table[55];

  size_t _M_index1;

  size_t _M_index2;

public:

  /// Returns a number less than the argument.

  unsigned int operator()(unsigned int __limit) {

    _M_index1 = (_M_index1 + 1) % 55;

    _M_index2 = (_M_index2 + 1) % 55;

    _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2];

    return _M_table[_M_index1] % __limit;

  }



  void _M_initialize(unsigned int __seed)

  {

    unsigned int __k = 1;

    _M_table[54] = __seed;

    size_t __i;

    for (__i = 0; __i < 54; __i++) {

        size_t __ii = (21 * (__i + 1) % 55) - 1;

        _M_table[__ii] = __k;

        __k = __seed - __k;

        __seed = _M_table[__ii];

    }

    for (int __loop = 0; __loop < 4; __loop++) {

        for (__i = 0; __i < 55; __i++)

            _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55];

    }

    _M_index1 = 0;

    _M_index2 = 31;

  }



  /// Ctor allowing you to initialize the seed.

  subtractive_rng(unsigned int __seed) { _M_initialize(__seed); }

  /// Default ctor; initializes its state with some number you don't see.

  subtractive_rng() { _M_initialize(161803398u); }

};



// Mem_fun adaptor helper functions mem_fun1 and mem_fun1_ref,

// provided for backward compatibility, they are no longer part of

// the C++ standard.



template <class _Ret, class _Tp, class _Arg>

inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg))

  { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }



template <class _Ret, class _Tp, class _Arg>

inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg) const)

  { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }



template <class _Ret, class _Tp, class _Arg>

inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg))

  { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }



template <class _Ret, class _Tp, class _Arg>

inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>

mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const)

  { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }

} // namespace __gnu_cxx



#endif