stl_map.h

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

                             clear()
                             { _M_t.clear(); }

                         // observers
                         /**
                          *  Returns the key comparison object out of which the %map 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 %map was constructed.
                          */
                         value_compare
                             value_comp() const
                             { return value_compare(_M_t.key_comp()); }

                         // [23.3.1.3] map operations
                         /**
                          *  @brief Tries to locate an element in a %map.
                          *  @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 %map.
                          *  @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.
                          *
                          *  This function only makes sense for multimaps; for map 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; }

                         /**
                          *  @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 it returns an iterator
                          *  pointing to the first element that has a greater value than given key
                          *  or end() if no such element exists.
                          */
                         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).
                          *
                          *  This function probably only makes sense for multimaps.
                          */
                         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).
                          *
                          *  This function probably only makes sense for multimaps.
                          */
                         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 map<_K1,_T1,_C1,_A1>&,
                                     const map<_K1,_T1,_C1,_A1>&);

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

    /**
     *  @brief  Map equality comparison.
     *  @param  x  A %map.
     *  @param  y  A %map 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
     *  maps.  Maps 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 map<_Key,_Tp,_Compare,_Alloc>& __x,
                const map<_Key,_Tp,_Compare,_Alloc>& __y)
        { return __x._M_t == __y._M_t; }

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

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

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

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

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

#endif /* _MAP_H */