stl_set.h

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

                /**
                 *  @brief Attempts to insert an element into the %set.
                 *  @param  x  Element to be inserted.
                 *  @return  A pair, of which the first element is an iterator that points
                 *           to the possibly inserted element, and the second is a bool
                 *           that is true if the element was actually inserted.
                 *
                 *  This function attempts to insert an element into the %set.  A %set
                 *  relies on unique keys and thus an element is only inserted if it is
                 *  not already present in the %set.
                 *
                 *  Insertion requires logarithmic time.
                 */
                pair<iterator,bool>
                    insert(const value_type& __x)
                    {
                        pair<typename _Rep_type::iterator, bool> __p = _M_t.insert_unique(__x);
                        return pair<iterator, bool>(__p.first, __p.second);
                    }

                /**
                 *  @brief Attempts to insert an element into the %set.
                 *  @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 element with key of @a x (may
                 *           or may not be the element passed in).
                 *
                 *  This function is not concerned about whether the insertion took place,
                 *  and thus does not return a boolean like the single-argument insert()
                 *  does.  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_unique((_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_unique(__first, __last); }

                /**
                 *  @brief Erases an element from a %set.
                 *  @param  position  An iterator pointing to the element to be erased.
                 *
                 *  This function erases an element, pointed to by the given iterator,
                 *  from a %set.  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 the elements located by the given key from
                 *  a %set.
                 *  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 %set.
                 *  @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 %set.
                 *  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 __first, iterator __last)
                    {
                        typedef typename _Rep_type::iterator _Rep_iterator;
                        _M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last);
                    }

                /**
                 *  Erases all elements in a %set.  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(); }

                // set operations:

                /**
                 *  @brief  Finds the number of elements.
                 *  @param  x  Element to located.
                 *  @return  Number of elements with specified key.
                 *
                 *  This function only makes sense for multisets; for set the result will
                 *  either be 0 (not present) or 1 (present).
                 */
                size_type
                    count(const key_type& __x) const
                    { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }

                // _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 set<_K1,_C1,_A1>&, const set<_K1,_C1,_A1>&);

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


    /**
     *  @brief  Set equality comparison.
     *  @param  x  A %set.
     *  @param  y  A %set of the same type as @a x.
     *  @return  True iff the size and elements of the sets are equal.
     *
     *  This is an equivalence relation.  It is linear in the size of the sets.
     *  Sets 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 set<_Key,_Compare,_Alloc>& __x,
                const set<_Key,_Compare,_Alloc>& __y)
        { return __x._M_t == __y._M_t; }

    /**
     *  @brief  Set ordering relation.
     *  @param  x  A %set.
     *  @param  y  A %set 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 set<_Key,_Compare,_Alloc>& __x,
                const set<_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 set<_Key,_Compare,_Alloc>& __x,
                const set<_Key,_Compare,_Alloc>& __y)
        { return !(__x == __y); }

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

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

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

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

} // namespace std

#endif /* _SET_H */