stl_multimap.h

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

                 *  @param  x  A %multimap of identical element and allocator types.
                 *
                 *  All the elements of @a x are copied, but unlike the copy constructor,
                 *  the allocator object is not copied.
                 */
                multimap&
                    operator=(const multimap& __x)
                    {
                        _M_t = __x._M_t;
                        return *this;
                    }

                /// Get a copy of the memory allocation object.
                allocator_type
                    get_allocator() const
                    { return _M_t.get_allocator(); }

                // iterators
                /**
                 *  Returns a read/write iterator that points to the first pair in the
                 *  %multimap.  Iteration is done in ascending order according to the
                 *  keys.
                 */
                iterator
                    begin()
                    { return _M_t.begin(); }

                /**
                 *  Returns a read-only (constant) iterator that points to the first pair
                 *  in the %multimap.  Iteration is done in ascending order according to
                 *  the keys.
                 */
                const_iterator
                    begin() const
                    { return _M_t.begin(); }

                /**
                 *  Returns a read/write iterator that points one past the last pair in
                 *  the %multimap.  Iteration is done in ascending order according to the
                 *  keys.
                 */
                iterator
                    end()
                    { return _M_t.end(); }

                /**
                 *  Returns a read-only (constant) iterator that points one past the last
                 *  pair in the %multimap.  Iteration is done in ascending order according
                 *  to the keys.
                 */
                const_iterator
                    end() const
                    { return _M_t.end(); }

                /**
                 *  Returns a read/write reverse iterator that points to the last pair in
                 *  the %multimap.  Iteration is done in descending order according to the
                 *  keys.
                 */
                reverse_iterator
                    rbegin()
                    { return _M_t.rbegin(); }

                /**
                 *  Returns a read-only (constant) reverse iterator that points to the
                 *  last pair in the %multimap.  Iteration is done in descending order
                 *  according to the keys.
                 */
                const_reverse_iterator
                    rbegin() const
                    { return _M_t.rbegin(); }

                /**
                 *  Returns a read/write reverse iterator that points to one before the
                 *  first pair in the %multimap.  Iteration is done in descending order
                 *  according to the keys.
                 */
                reverse_iterator
                    rend()
                    { return _M_t.rend(); }

                /**
                 *  Returns a read-only (constant) reverse iterator that points to one
                 *  before the first pair in the %multimap.  Iteration is done in
                 *  descending order according to the keys.
                 */
                const_reverse_iterator
                    rend() const
                    { return _M_t.rend(); }

                // capacity
                /** Returns true if the %multimap is empty.  */
                bool
                    empty() const
                    { return _M_t.empty(); }

                /** Returns the size of the %multimap.  */
                size_type
                    size() const
                    { return _M_t.size(); }

                /** Returns the maximum size of the %multimap.  */
                size_type
                    max_size() const
                    { return _M_t.max_size(); }

                // modifiers
                /**
                 *  @brief Inserts a std::pair into the %multimap.
                 *  @param  x  Pair to be inserted (see std::make_pair for easy creation
                 *             of pairs).
                 *  @return An iterator that points to the inserted (key,value) pair.
                 *
                 *  This function inserts a (key, value) pair into the %multimap.
                 *  Contrary to a std::map the %multimap does not rely on unique keys and
                 *  thus multiple pairs with the same key can be inserted.
                 *
                 *  Insertion requires logarithmic time.
                 */
                iterator
                    insert(const value_type& __x)
                    { return _M_t.insert_equal(__x); }

                /**
                 *  @brief Inserts a std::pair into the %multimap.
                 *  @param  position  An iterator that serves as a hint as to where the
                 *                    pair should be inserted.
                 *  @param  x  Pair to be inserted (see std::make_pair for easy creation
                 *             of pairs).
                 *  @return An iterator that points to the inserted (key,value) pair.
                 *
                 *  This function inserts a (key, value) pair into the %multimap.
                 *  Contrary to a std::map the %multimap does not rely on unique keys and
                 *  thus multiple pairs with the same key 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)
                    { return _M_t.insert_equal(__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 <typename _InputIterator>
                    void
                    insert(_InputIterator __first, _InputIterator __last)
                    { _M_t.insert_equal(__first, __last); }

                /**
                 *  @brief Erases an element from a %multimap.
                 *  @param  position  An iterator pointing to the element to be erased.
                 *
                 *  This function erases an element, pointed to by the given iterator,
                 *  from a %multimap.  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)
                    { _M_t.erase(__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
                 *  %multimap.
                 *  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 %multimap.
                 *  @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 %multimap.
                 *  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)
                    { _M_t.erase(__first, __last); }

                /**
                 *  @brief  Swaps data with another %multimap.
                 *  @param  x  A %multimap of the same element and allocator types.
                 *
                 *  This exchanges the elements between two multimaps in constant time.
                 *  (It is only swapping a pointer, an integer, and an instance of
                 *  the @c Compare type (which itself is often stateless and empty), so it
                 *  should be quite fast.)
                 *  Note that the global std::swap() function is specialized such that
                 *  std::swap(m1,m2) will feed to this function.
                 */
                void
                    swap(multimap& __x)
                    { _M_t.swap(__x._M_t); }

                /**
                 *  Erases all elements in a %multimap.  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