stl_multimap.h

来自「symbian上STL模板库的实现」· C头文件 代码 · 共 678 行 · 第 1/3 页

                    clear()
                    { _M_t.clear(); }

                // observers
                /**
                 *  Returns the key comparison object out of which the %multimap
                 *  was constructed.
                 */
                key_compare
                    key_comp() const
                    { return _M_t.key_comp(); }

                /**
                 *  Returns a value comparison object, built from the key comparison
                 *  object out of which the %multimap was constructed.
                 */
                value_compare
                    value_comp() const
                    { return value_compare(_M_t.key_comp()); }

                // multimap operations
                /**
                 *  @brief Tries to locate an element in a %multimap.
                 *  @param  x  Key of (key, value) pair to be located.
                 *  @return  Iterator pointing to sought-after element,
                 *           or end() if not found.
                 *
                 *  This function takes a key and tries to locate the element with which
                 *  the key matches.  If successful the function returns an iterator
                 *  pointing to the sought after %pair.  If unsuccessful it returns the
                 *  past-the-end ( @c end() ) iterator.
                 */
                iterator
                    find(const key_type& __x)
                    { return _M_t.find(__x); }

                /**
                 *  @brief Tries to locate an element in a %multimap.
                 *  @param  x  Key of (key, value) pair to be located.
                 *  @return  Read-only (constant) iterator pointing to sought-after
                 *           element, or end() if not found.
                 *
                 *  This function takes a key and tries to locate the element with which
                 *  the key matches.  If successful the function returns a constant
                 *  iterator pointing to the sought after %pair.  If unsuccessful it
                 *  returns the past-the-end ( @c end() ) iterator.
                 */
                const_iterator
                    find(const key_type& __x) const
                    { return _M_t.find(__x); }

                /**
                 *  @brief Finds the number of elements with given key.
                 *  @param  x  Key of (key, value) pairs to be located.
                 *  @return Number of elements with specified key.
                 */
                size_type
                    count(const key_type& __x) const
                    { return _M_t.count(__x); }

                /**
                 *  @brief Finds the beginning of a subsequence matching given key.
                 *  @param  x  Key of (key, value) pair to be located.
                 *  @return  Iterator pointing to first element equal to or greater
                 *           than key, or end().
                 *
                 *  This function returns the first element of a subsequence of elements
                 *  that matches the given key.  If unsuccessful it returns an iterator
                 *  pointing to the first element that has a greater value than given key
                 *  or end() if no such element exists.
                 */
                iterator
                    lower_bound(const key_type& __x)
                    { return _M_t.lower_bound(__x); }

                /**
                 *  @brief Finds the beginning of a subsequence matching given key.
                 *  @param  x  Key of (key, value) pair to be located.
                 *  @return  Read-only (constant) iterator pointing to first element
                 *           equal to or greater than key, or end().
                 *
                 *  This function returns the first element of a subsequence of elements
                 *  that matches the given key.  If unsuccessful the iterator will point
                 *  to the next greatest element or, if no such greater element exists, to
                 *  end().
                 */
                const_iterator
                    lower_bound(const key_type& __x) const
                    { return _M_t.lower_bound(__x); }

                /**
                 *  @brief Finds the end of a subsequence matching given key.
                 *  @param  x  Key of (key, value) pair to be located.
                 *  @return Iterator pointing to the first element
                 *          greater than key, or end().
                 */
                iterator
                    upper_bound(const key_type& __x)
                    { return _M_t.upper_bound(__x); }

                /**
                 *  @brief Finds the end of a subsequence matching given key.
                 *  @param  x  Key of (key, value) pair to be located.
                 *  @return  Read-only (constant) iterator pointing to first iterator
                 *           greater than key, or end().
                 */
                const_iterator
                    upper_bound(const key_type& __x) const
                    { return _M_t.upper_bound(__x); }

                /**
                 *  @brief Finds a subsequence matching given key.
                 *  @param  x  Key of (key, value) pairs to be located.
                 *  @return  Pair of iterators that possibly points to the subsequence
                 *           matching given key.
                 *
                 *  This function is equivalent to
                 *  @code
                 *    std::make_pair(c.lower_bound(val),
                 *                   c.upper_bound(val))
                 *  @endcode
                 *  (but is faster than making the calls separately).
                 */
                pair<iterator,iterator>
                    equal_range(const key_type& __x)
                    { return _M_t.equal_range(__x); }

                /**
                 *  @brief Finds a subsequence matching given key.
                 *  @param  x  Key of (key, value) pairs to be located.
                 *  @return  Pair of read-only (constant) iterators that possibly points
                 *           to the subsequence matching given key.
                 *
                 *  This function is equivalent to
                 *  @code
                 *    std::make_pair(c.lower_bound(val),
                 *                   c.upper_bound(val))
                 *  @endcode
                 *  (but is faster than making the calls separately).
                 */
                pair<const_iterator,const_iterator>
                    equal_range(const key_type& __x) const
                    { return _M_t.equal_range(__x); }

                template <typename _K1, typename _T1, typename _C1, typename _A1>
                    friend bool
                    operator== (const multimap<_K1,_T1,_C1,_A1>&,
                            const multimap<_K1,_T1,_C1,_A1>&);

                template <typename _K1, typename _T1, typename _C1, typename _A1>
                    friend bool
                    operator< (const multimap<_K1,_T1,_C1,_A1>&,
                            const multimap<_K1,_T1,_C1,_A1>&);
        };

    /**
     *  @brief  Multimap equality comparison.
     *  @param  x  A %multimap.
     *  @param  y  A %multimap of the same type as @a x.
     *  @return  True iff the size and elements of the maps are equal.
     *
     *  This is an equivalence relation.  It is linear in the size of the
     *  multimaps.  Multimaps are considered equivalent if their sizes are equal,
     *  and if corresponding elements compare equal.
     */
    template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
        inline bool
        operator==(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                const multimap<_Key,_Tp,_Compare,_Alloc>& __y)
        { return __x._M_t == __y._M_t; }

    /**
     *  @brief  Multimap ordering relation.
     *  @param  x  A %multimap.
     *  @param  y  A %multimap of the same type as @a x.
     *  @return  True iff @a x is lexicographically less than @a y.
     *
     *  This is a total ordering relation.  It is linear in the size of the
     *  multimaps.  The elements must be comparable with @c <.
     *
     *  See std::lexicographical_compare() for how the determination is made.
     */
    template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
        inline bool
        operator<(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                const multimap<_Key,_Tp,_Compare,_Alloc>& __y)
        { return __x._M_t < __y._M_t; }

    /// Based on operator==
    template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
        inline bool
        operator!=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                const multimap<_Key,_Tp,_Compare,_Alloc>& __y)
        { return !(__x == __y); }

    /// Based on operator<
    template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
        inline bool
        operator>(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                const multimap<_Key,_Tp,_Compare,_Alloc>& __y)
        { return __y < __x; }

    /// Based on operator<
    template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
        inline bool
        operator<=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                const multimap<_Key,_Tp,_Compare,_Alloc>& __y)
        { return !(__y < __x); }

    /// Based on operator<
    template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
        inline bool
        operator>=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                const multimap<_Key,_Tp,_Compare,_Alloc>& __y)
        { return !(__x < __y); }

    /// See std::multimap::swap().
    template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
        inline void
        swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                multimap<_Key,_Tp,_Compare,_Alloc>& __y)
        { __x.swap(__y); }
} // namespace std

#endif /* _MULTIMAP_H */