functional

symbian上STL模板库的实现

    /// 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