stl_multiset.h

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

                 *  @brief Inserts an element into the %multiset.
                 *  @param  x  Element to be inserted.
                 *  @return An iterator that points to the inserted element.
                 *
                 *  This function inserts an element into the %multiset.  Contrary
                 *  to a std::set the %multiset does not rely on unique keys and thus
                 *  multiple copies of the same element can be inserted.
                 *
                 *  Insertion requires logarithmic time.
                 */
                iterator
                    insert(const value_type& __x)
                    { return _M_t.insert_equal(__x); }

                /**
                 *  @brief Inserts an element into the %multiset.
                 *  @param  position  An iterator that serves as a hint as to where the
                 *                    element should be inserted.
                 *  @param  x  Element to be inserted.
                 *  @return An iterator that points to the inserted element.
                 *
                 *  This function inserts an element into the %multiset.  Contrary
                 *  to a std::set the %multiset does not rely on unique keys and thus
                 *  multiple copies of the same element can be inserted.
                 *
                 *  Note that the first parameter is only a hint and can potentially
                 *  improve the performance of the insertion process.  A bad hint would
                 *  cause no gains in efficiency.
                 *
                 *  See http://gcc.gnu.org/onlinedocs/libstdc++/23_containers/howto.html#4
                 *  for more on "hinting".
                 *
                 *  Insertion requires logarithmic time (if the hint is not taken).
                 */
                iterator
                    insert(iterator __position, const value_type& __x)
                    {
                        typedef typename _Rep_type::iterator _Rep_iterator;
                        return _M_t.insert_equal((_Rep_iterator&)__position, __x);
                    }

                /**
                 *  @brief A template function that attemps to insert a range of elements.
                 *  @param  first  Iterator pointing to the start of the range to be
                 *                 inserted.
                 *  @param  last  Iterator pointing to the end of the range.
                 *
                 *  Complexity similar to that of the range constructor.
                 */
                template <class _InputIterator>
                    void
                    insert(_InputIterator __first, _InputIterator __last)
                    { _M_t.insert_equal(__first, __last); }

                /**
                 *  @brief Erases an element from a %multiset.
                 *  @param  position  An iterator pointing to the element to be erased.
                 *
                 *  This function erases an element, pointed to by the given iterator,
                 *  from a %multiset.  Note that this function only erases the element,
                 *  and that if the element is itself a pointer, the pointed-to memory is
                 *  not touched in any way.  Managing the pointer is the user's
                 *  responsibilty.
                 */
                void
                    erase(iterator __position)
                    {
                        typedef typename _Rep_type::iterator _Rep_iterator;
                        _M_t.erase((_Rep_iterator&)__position);
                    }

                /**
                 *  @brief Erases elements according to the provided key.
                 *  @param  x  Key of element to be erased.
                 *  @return  The number of elements erased.
                 *
                 *  This function erases all elements located by the given key from a
                 *  %multiset.
                 *  Note that this function only erases the element, and that if
                 *  the element is itself a pointer, the pointed-to memory is not touched
                 *  in any way.  Managing the pointer is the user's responsibilty.
                 */
                size_type
                    erase(const key_type& __x)
                    { return _M_t.erase(__x); }

                /**
                 *  @brief Erases a [first,last) range of elements from a %multiset.
                 *  @param  first  Iterator pointing to the start of the range to be
                 *                 erased.
                 *  @param  last  Iterator pointing to the end of the range to be erased.
                 *
                 *  This function erases a sequence of elements from a %multiset.
                 *  Note that this function only erases the elements, and that if
                 *  the elements themselves are pointers, the pointed-to memory is not
                 *  touched in any way.  Managing the pointer is the user's responsibilty.
                 */
                void
                    erase(iterator __first, iterator __last)
                    {
                        typedef typename _Rep_type::iterator _Rep_iterator;
                        _M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last);
                    }

                /**
                 *  Erases all elements in a %multiset.  Note that this function only
                 *  erases the elements, and that if the elements themselves are pointers,
                 *  the pointed-to memory is not touched in any way.  Managing the pointer
                 *  is the user's responsibilty.
                 */
                void
                    clear()
                    { _M_t.clear(); }

                // multiset operations:

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

                // _GLIBCXX_RESOLVE_LIB_DEFECTS
                // 214.  set::find() missing const overload
                //@{
                /**
                 *  @brief Tries to locate an element in a %set.
                 *  @param  x  Element 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 element.  If unsuccessful it returns the
                 *  past-the-end ( @c end() ) iterator.
                 */
                iterator
                    find(const key_type& __x)
                    { return _M_t.find(__x); }

                const_iterator
                    find(const key_type& __x) const
                    { return _M_t.find(__x); }
                //@}

                //@{
                /**
                 *  @brief Finds the beginning of a subsequence matching given key.
                 *  @param  x  Key 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); }

                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 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); }

                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 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).
                 *
                 *  This function probably only makes sense for multisets.
                 */
                pair<iterator,iterator>
                    equal_range(const key_type& __x)
                    { return _M_t.equal_range(__x); }

                pair<const_iterator,const_iterator>
                    equal_range(const key_type& __x) const
                    { return _M_t.equal_range(__x); }

                template <class _K1, class _C1, class _A1>
                    friend bool
                    operator== (const multiset<_K1,_C1,_A1>&,
                            const multiset<_K1,_C1,_A1>&);

                template <class _K1, class _C1, class _A1>
                    friend bool
                    operator< (const multiset<_K1,_C1,_A1>&,
                            const multiset<_K1,_C1,_A1>&);
        };

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

        /**
         *  @brief  Multiset ordering relation.
         *  @param  x  A %multiset.
         *  @param  y  A %multiset 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
         *  maps.  The elements must be comparable with @c <.
         *
         *  See std::lexicographical_compare() for how the determination is made.
         */
        template <class _Key, class _Compare, class _Alloc>
            inline bool
            operator<(const multiset<_Key,_Compare,_Alloc>& __x,
                    const multiset<_Key,_Compare,_Alloc>& __y)
            { return __x._M_t < __y._M_t; }

        ///  Returns !(x == y).
        template <class _Key, class _Compare, class _Alloc>
            inline bool
            operator!=(const multiset<_Key,_Compare,_Alloc>& __x,
                    const multiset<_Key,_Compare,_Alloc>& __y)
            { return !(__x == __y); }

        ///  Returns y < x.
        template <class _Key, class _Compare, class _Alloc>
            inline bool
            operator>(const multiset<_Key,_Compare,_Alloc>& __x,
                    const multiset<_Key,_Compare,_Alloc>& __y)
            { return __y < __x; }

        ///  Returns !(y < x)
        template <class _Key, class _Compare, class _Alloc>
            inline bool
            operator<=(const multiset<_Key,_Compare,_Alloc>& __x,
                    const multiset<_Key,_Compare,_Alloc>& __y)
            { return !(__y < __x); }

        ///  Returns !(x < y)
        template <class _Key, class _Compare, class _Alloc>
            inline bool
            operator>=(const multiset<_Key,_Compare,_Alloc>& __x,
                    const multiset<_Key,_Compare,_Alloc>& __y)
            { return !(__x < __y); }

        /// See std::multiset::swap().
        template <class _Key, class _Compare, class _Alloc>
            inline void
            swap(multiset<_Key,_Compare,_Alloc>& __x,
                    multiset<_Key,_Compare,_Alloc>& __y)
            { __x.swap(__y); }

        } // namespace std

#endif /* _MULTISET_H */