2010-05-12 03:42:16 +08:00
|
|
|
// -*- C++ -*-
|
|
|
|
//===----------------------------- map ------------------------------------===//
|
|
|
|
//
|
2019-01-19 18:56:40 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2010-05-12 03:42:16 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#ifndef _LIBCPP_MAP
|
|
|
|
#define _LIBCPP_MAP
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
map synopsis
|
|
|
|
|
|
|
|
namespace std
|
|
|
|
{
|
|
|
|
|
|
|
|
template <class Key, class T, class Compare = less<Key>,
|
|
|
|
class Allocator = allocator<pair<const Key, T>>>
|
|
|
|
class map
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
// types:
|
|
|
|
typedef Key key_type;
|
|
|
|
typedef T mapped_type;
|
|
|
|
typedef pair<const key_type, mapped_type> value_type;
|
|
|
|
typedef Compare key_compare;
|
|
|
|
typedef Allocator allocator_type;
|
|
|
|
typedef typename allocator_type::reference reference;
|
|
|
|
typedef typename allocator_type::const_reference const_reference;
|
|
|
|
typedef typename allocator_type::pointer pointer;
|
|
|
|
typedef typename allocator_type::const_pointer const_pointer;
|
|
|
|
typedef typename allocator_type::size_type size_type;
|
|
|
|
typedef typename allocator_type::difference_type difference_type;
|
|
|
|
|
|
|
|
typedef implementation-defined iterator;
|
|
|
|
typedef implementation-defined const_iterator;
|
|
|
|
typedef std::reverse_iterator<iterator> reverse_iterator;
|
|
|
|
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
2018-08-01 09:33:38 +08:00
|
|
|
typedef unspecified node_type; // C++17
|
|
|
|
typedef INSERT_RETURN_TYPE<iterator, node_type> insert_return_type; // C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
class value_compare
|
|
|
|
: public binary_function<value_type, value_type, bool>
|
|
|
|
{
|
|
|
|
friend class map;
|
|
|
|
protected:
|
|
|
|
key_compare comp;
|
|
|
|
|
|
|
|
value_compare(key_compare c);
|
|
|
|
public:
|
|
|
|
bool operator()(const value_type& x, const value_type& y) const;
|
|
|
|
};
|
|
|
|
|
|
|
|
// construct/copy/destroy:
|
2011-06-04 22:31:57 +08:00
|
|
|
map()
|
|
|
|
noexcept(
|
|
|
|
is_nothrow_default_constructible<allocator_type>::value &&
|
|
|
|
is_nothrow_default_constructible<key_compare>::value &&
|
|
|
|
is_nothrow_copy_constructible<key_compare>::value);
|
2010-05-12 03:42:16 +08:00
|
|
|
explicit map(const key_compare& comp);
|
|
|
|
map(const key_compare& comp, const allocator_type& a);
|
|
|
|
template <class InputIterator>
|
|
|
|
map(InputIterator first, InputIterator last,
|
|
|
|
const key_compare& comp = key_compare());
|
|
|
|
template <class InputIterator>
|
|
|
|
map(InputIterator first, InputIterator last,
|
|
|
|
const key_compare& comp, const allocator_type& a);
|
|
|
|
map(const map& m);
|
2011-06-04 22:31:57 +08:00
|
|
|
map(map&& m)
|
|
|
|
noexcept(
|
|
|
|
is_nothrow_move_constructible<allocator_type>::value &&
|
|
|
|
is_nothrow_move_constructible<key_compare>::value);
|
2010-05-12 03:42:16 +08:00
|
|
|
explicit map(const allocator_type& a);
|
|
|
|
map(const map& m, const allocator_type& a);
|
|
|
|
map(map&& m, const allocator_type& a);
|
|
|
|
map(initializer_list<value_type> il, const key_compare& comp = key_compare());
|
|
|
|
map(initializer_list<value_type> il, const key_compare& comp, const allocator_type& a);
|
2013-09-11 09:15:47 +08:00
|
|
|
template <class InputIterator>
|
|
|
|
map(InputIterator first, InputIterator last, const allocator_type& a)
|
|
|
|
: map(first, last, Compare(), a) {} // C++14
|
|
|
|
map(initializer_list<value_type> il, const allocator_type& a)
|
|
|
|
: map(il, Compare(), a) {} // C++14
|
|
|
|
~map();
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
map& operator=(const map& m);
|
2011-06-04 22:31:57 +08:00
|
|
|
map& operator=(map&& m)
|
|
|
|
noexcept(
|
|
|
|
allocator_type::propagate_on_container_move_assignment::value &&
|
|
|
|
is_nothrow_move_assignable<allocator_type>::value &&
|
2011-06-04 23:22:34 +08:00
|
|
|
is_nothrow_move_assignable<key_compare>::value);
|
2010-05-12 03:42:16 +08:00
|
|
|
map& operator=(initializer_list<value_type> il);
|
|
|
|
|
|
|
|
// iterators:
|
2011-06-04 23:22:34 +08:00
|
|
|
iterator begin() noexcept;
|
|
|
|
const_iterator begin() const noexcept;
|
|
|
|
iterator end() noexcept;
|
|
|
|
const_iterator end() const noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-06-04 23:22:34 +08:00
|
|
|
reverse_iterator rbegin() noexcept;
|
|
|
|
const_reverse_iterator rbegin() const noexcept;
|
|
|
|
reverse_iterator rend() noexcept;
|
|
|
|
const_reverse_iterator rend() const noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-06-04 23:22:34 +08:00
|
|
|
const_iterator cbegin() const noexcept;
|
|
|
|
const_iterator cend() const noexcept;
|
|
|
|
const_reverse_iterator crbegin() const noexcept;
|
|
|
|
const_reverse_iterator crend() const noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
// capacity:
|
2011-06-04 23:22:34 +08:00
|
|
|
bool empty() const noexcept;
|
|
|
|
size_type size() const noexcept;
|
|
|
|
size_type max_size() const noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
// element access:
|
|
|
|
mapped_type& operator[](const key_type& k);
|
|
|
|
mapped_type& operator[](key_type&& k);
|
|
|
|
|
|
|
|
mapped_type& at(const key_type& k);
|
|
|
|
const mapped_type& at(const key_type& k) const;
|
|
|
|
|
|
|
|
// modifiers:
|
|
|
|
template <class... Args>
|
|
|
|
pair<iterator, bool> emplace(Args&&... args);
|
|
|
|
template <class... Args>
|
|
|
|
iterator emplace_hint(const_iterator position, Args&&... args);
|
|
|
|
pair<iterator, bool> insert(const value_type& v);
|
2016-01-06 03:32:41 +08:00
|
|
|
pair<iterator, bool> insert( value_type&& v); // C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class P>
|
|
|
|
pair<iterator, bool> insert(P&& p);
|
|
|
|
iterator insert(const_iterator position, const value_type& v);
|
2016-01-06 03:32:41 +08:00
|
|
|
iterator insert(const_iterator position, value_type&& v); // C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class P>
|
|
|
|
iterator insert(const_iterator position, P&& p);
|
|
|
|
template <class InputIterator>
|
|
|
|
void insert(InputIterator first, InputIterator last);
|
|
|
|
void insert(initializer_list<value_type> il);
|
|
|
|
|
2018-08-01 09:33:38 +08:00
|
|
|
node_type extract(const_iterator position); // C++17
|
|
|
|
node_type extract(const key_type& x); // C++17
|
|
|
|
insert_return_type insert(node_type&& nh); // C++17
|
|
|
|
iterator insert(const_iterator hint, node_type&& nh); // C++17
|
|
|
|
|
2015-07-07 11:37:33 +08:00
|
|
|
template <class... Args>
|
|
|
|
pair<iterator, bool> try_emplace(const key_type& k, Args&&... args); // C++17
|
|
|
|
template <class... Args>
|
|
|
|
pair<iterator, bool> try_emplace(key_type&& k, Args&&... args); // C++17
|
|
|
|
template <class... Args>
|
|
|
|
iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); // C++17
|
|
|
|
template <class... Args>
|
|
|
|
iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); // C++17
|
|
|
|
template <class M>
|
|
|
|
pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj); // C++17
|
|
|
|
template <class M>
|
|
|
|
pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj); // C++17
|
|
|
|
template <class M>
|
|
|
|
iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); // C++17
|
|
|
|
template <class M>
|
|
|
|
iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); // C++17
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator erase(const_iterator position);
|
2015-05-10 21:35:00 +08:00
|
|
|
iterator erase(iterator position); // C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
size_type erase(const key_type& k);
|
|
|
|
iterator erase(const_iterator first, const_iterator last);
|
2011-06-04 23:22:34 +08:00
|
|
|
void clear() noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2018-11-01 01:31:35 +08:00
|
|
|
template<class C2>
|
|
|
|
void merge(map<Key, T, C2, Allocator>& source); // C++17
|
|
|
|
template<class C2>
|
|
|
|
void merge(map<Key, T, C2, Allocator>&& source); // C++17
|
|
|
|
template<class C2>
|
|
|
|
void merge(multimap<Key, T, C2, Allocator>& source); // C++17
|
|
|
|
template<class C2>
|
|
|
|
void merge(multimap<Key, T, C2, Allocator>&& source); // C++17
|
|
|
|
|
2011-06-04 22:31:57 +08:00
|
|
|
void swap(map& m)
|
2015-07-14 04:04:56 +08:00
|
|
|
noexcept(allocator_traits<allocator_type>::is_always_equal::value &&
|
2016-04-22 07:38:59 +08:00
|
|
|
is_nothrow_swappable<key_compare>::value); // C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
// observers:
|
2011-06-04 23:22:34 +08:00
|
|
|
allocator_type get_allocator() const noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
key_compare key_comp() const;
|
|
|
|
value_compare value_comp() const;
|
|
|
|
|
|
|
|
// map operations:
|
|
|
|
iterator find(const key_type& k);
|
|
|
|
const_iterator find(const key_type& k) const;
|
2013-08-14 06:18:47 +08:00
|
|
|
template<typename K>
|
|
|
|
iterator find(const K& x); // C++14
|
|
|
|
template<typename K>
|
|
|
|
const_iterator find(const K& x) const; // C++14
|
|
|
|
template<typename K>
|
2014-08-25 07:54:16 +08:00
|
|
|
size_type count(const K& x) const; // C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
size_type count(const key_type& k) const;
|
2019-07-16 11:21:01 +08:00
|
|
|
bool contains(const key_type& x) const; // C++20
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator lower_bound(const key_type& k);
|
|
|
|
const_iterator lower_bound(const key_type& k) const;
|
2013-08-14 06:18:47 +08:00
|
|
|
template<typename K>
|
|
|
|
iterator lower_bound(const K& x); // C++14
|
|
|
|
template<typename K>
|
|
|
|
const_iterator lower_bound(const K& x) const; // C++14
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator upper_bound(const key_type& k);
|
|
|
|
const_iterator upper_bound(const key_type& k) const;
|
2013-08-14 06:18:47 +08:00
|
|
|
template<typename K>
|
|
|
|
iterator upper_bound(const K& x); // C++14
|
|
|
|
template<typename K>
|
|
|
|
const_iterator upper_bound(const K& x) const; // C++14
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
pair<iterator,iterator> equal_range(const key_type& k);
|
|
|
|
pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
|
2013-08-14 06:18:47 +08:00
|
|
|
template<typename K>
|
|
|
|
pair<iterator,iterator> equal_range(const K& x); // C++14
|
|
|
|
template<typename K>
|
|
|
|
pair<const_iterator,const_iterator> equal_range(const K& x) const; // C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
template <class Key, class T, class Compare, class Allocator>
|
|
|
|
bool
|
|
|
|
operator==(const map<Key, T, Compare, Allocator>& x,
|
|
|
|
const map<Key, T, Compare, Allocator>& y);
|
|
|
|
|
|
|
|
template <class Key, class T, class Compare, class Allocator>
|
|
|
|
bool
|
|
|
|
operator< (const map<Key, T, Compare, Allocator>& x,
|
|
|
|
const map<Key, T, Compare, Allocator>& y);
|
|
|
|
|
|
|
|
template <class Key, class T, class Compare, class Allocator>
|
|
|
|
bool
|
|
|
|
operator!=(const map<Key, T, Compare, Allocator>& x,
|
|
|
|
const map<Key, T, Compare, Allocator>& y);
|
|
|
|
|
|
|
|
template <class Key, class T, class Compare, class Allocator>
|
|
|
|
bool
|
|
|
|
operator> (const map<Key, T, Compare, Allocator>& x,
|
|
|
|
const map<Key, T, Compare, Allocator>& y);
|
|
|
|
|
|
|
|
template <class Key, class T, class Compare, class Allocator>
|
|
|
|
bool
|
|
|
|
operator>=(const map<Key, T, Compare, Allocator>& x,
|
|
|
|
const map<Key, T, Compare, Allocator>& y);
|
|
|
|
|
|
|
|
template <class Key, class T, class Compare, class Allocator>
|
|
|
|
bool
|
|
|
|
operator<=(const map<Key, T, Compare, Allocator>& x,
|
|
|
|
const map<Key, T, Compare, Allocator>& y);
|
|
|
|
|
|
|
|
// specialized algorithms:
|
|
|
|
template <class Key, class T, class Compare, class Allocator>
|
|
|
|
void
|
2011-06-04 22:31:57 +08:00
|
|
|
swap(map<Key, T, Compare, Allocator>& x, map<Key, T, Compare, Allocator>& y)
|
|
|
|
noexcept(noexcept(x.swap(y)));
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2018-12-15 02:49:35 +08:00
|
|
|
template <class Key, class T, class Compare, class Allocator, class Predicate>
|
2020-05-02 19:58:03 +08:00
|
|
|
typename map<Key, T, Compare, Allocator>::size_type
|
|
|
|
erase_if(map<Key, T, Compare, Allocator>& c, Predicate pred); // C++20
|
2018-12-15 02:49:35 +08:00
|
|
|
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class Key, class T, class Compare = less<Key>,
|
|
|
|
class Allocator = allocator<pair<const Key, T>>>
|
|
|
|
class multimap
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
// types:
|
|
|
|
typedef Key key_type;
|
|
|
|
typedef T mapped_type;
|
|
|
|
typedef pair<const key_type,mapped_type> value_type;
|
|
|
|
typedef Compare key_compare;
|
|
|
|
typedef Allocator allocator_type;
|
|
|
|
typedef typename allocator_type::reference reference;
|
|
|
|
typedef typename allocator_type::const_reference const_reference;
|
|
|
|
typedef typename allocator_type::size_type size_type;
|
|
|
|
typedef typename allocator_type::difference_type difference_type;
|
|
|
|
typedef typename allocator_type::pointer pointer;
|
|
|
|
typedef typename allocator_type::const_pointer const_pointer;
|
|
|
|
|
|
|
|
typedef implementation-defined iterator;
|
|
|
|
typedef implementation-defined const_iterator;
|
|
|
|
typedef std::reverse_iterator<iterator> reverse_iterator;
|
|
|
|
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
2018-08-01 09:33:38 +08:00
|
|
|
typedef unspecified node_type; // C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
class value_compare
|
|
|
|
: public binary_function<value_type,value_type,bool>
|
|
|
|
{
|
|
|
|
friend class multimap;
|
|
|
|
protected:
|
|
|
|
key_compare comp;
|
|
|
|
value_compare(key_compare c);
|
|
|
|
public:
|
|
|
|
bool operator()(const value_type& x, const value_type& y) const;
|
|
|
|
};
|
|
|
|
|
|
|
|
// construct/copy/destroy:
|
2011-06-04 22:31:57 +08:00
|
|
|
multimap()
|
|
|
|
noexcept(
|
|
|
|
is_nothrow_default_constructible<allocator_type>::value &&
|
|
|
|
is_nothrow_default_constructible<key_compare>::value &&
|
|
|
|
is_nothrow_copy_constructible<key_compare>::value);
|
|
|
|
explicit multimap(const key_compare& comp);
|
2010-05-12 03:42:16 +08:00
|
|
|
multimap(const key_compare& comp, const allocator_type& a);
|
|
|
|
template <class InputIterator>
|
|
|
|
multimap(InputIterator first, InputIterator last, const key_compare& comp);
|
|
|
|
template <class InputIterator>
|
|
|
|
multimap(InputIterator first, InputIterator last, const key_compare& comp,
|
|
|
|
const allocator_type& a);
|
|
|
|
multimap(const multimap& m);
|
2011-06-04 22:31:57 +08:00
|
|
|
multimap(multimap&& m)
|
|
|
|
noexcept(
|
|
|
|
is_nothrow_move_constructible<allocator_type>::value &&
|
|
|
|
is_nothrow_move_constructible<key_compare>::value);
|
2010-05-12 03:42:16 +08:00
|
|
|
explicit multimap(const allocator_type& a);
|
|
|
|
multimap(const multimap& m, const allocator_type& a);
|
|
|
|
multimap(multimap&& m, const allocator_type& a);
|
|
|
|
multimap(initializer_list<value_type> il, const key_compare& comp = key_compare());
|
|
|
|
multimap(initializer_list<value_type> il, const key_compare& comp,
|
|
|
|
const allocator_type& a);
|
2013-09-11 09:15:47 +08:00
|
|
|
template <class InputIterator>
|
|
|
|
multimap(InputIterator first, InputIterator last, const allocator_type& a)
|
|
|
|
: multimap(first, last, Compare(), a) {} // C++14
|
|
|
|
multimap(initializer_list<value_type> il, const allocator_type& a)
|
|
|
|
: multimap(il, Compare(), a) {} // C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
~multimap();
|
|
|
|
|
|
|
|
multimap& operator=(const multimap& m);
|
2011-06-04 22:31:57 +08:00
|
|
|
multimap& operator=(multimap&& m)
|
|
|
|
noexcept(
|
|
|
|
allocator_type::propagate_on_container_move_assignment::value &&
|
|
|
|
is_nothrow_move_assignable<allocator_type>::value &&
|
2011-06-04 23:22:34 +08:00
|
|
|
is_nothrow_move_assignable<key_compare>::value);
|
2010-05-12 03:42:16 +08:00
|
|
|
multimap& operator=(initializer_list<value_type> il);
|
|
|
|
|
|
|
|
// iterators:
|
2011-06-04 23:22:34 +08:00
|
|
|
iterator begin() noexcept;
|
|
|
|
const_iterator begin() const noexcept;
|
|
|
|
iterator end() noexcept;
|
|
|
|
const_iterator end() const noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-06-04 23:22:34 +08:00
|
|
|
reverse_iterator rbegin() noexcept;
|
|
|
|
const_reverse_iterator rbegin() const noexcept;
|
|
|
|
reverse_iterator rend() noexcept;
|
|
|
|
const_reverse_iterator rend() const noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-06-04 23:22:34 +08:00
|
|
|
const_iterator cbegin() const noexcept;
|
|
|
|
const_iterator cend() const noexcept;
|
|
|
|
const_reverse_iterator crbegin() const noexcept;
|
|
|
|
const_reverse_iterator crend() const noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
// capacity:
|
2011-06-04 23:22:34 +08:00
|
|
|
bool empty() const noexcept;
|
|
|
|
size_type size() const noexcept;
|
|
|
|
size_type max_size() const noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
// modifiers:
|
|
|
|
template <class... Args>
|
|
|
|
iterator emplace(Args&&... args);
|
|
|
|
template <class... Args>
|
|
|
|
iterator emplace_hint(const_iterator position, Args&&... args);
|
|
|
|
iterator insert(const value_type& v);
|
2016-01-06 03:32:41 +08:00
|
|
|
iterator insert( value_type&& v); // C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class P>
|
|
|
|
iterator insert(P&& p);
|
|
|
|
iterator insert(const_iterator position, const value_type& v);
|
2016-01-06 03:32:41 +08:00
|
|
|
iterator insert(const_iterator position, value_type&& v); // C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class P>
|
|
|
|
iterator insert(const_iterator position, P&& p);
|
|
|
|
template <class InputIterator>
|
|
|
|
void insert(InputIterator first, InputIterator last);
|
|
|
|
void insert(initializer_list<value_type> il);
|
|
|
|
|
2018-08-01 09:33:38 +08:00
|
|
|
node_type extract(const_iterator position); // C++17
|
|
|
|
node_type extract(const key_type& x); // C++17
|
|
|
|
iterator insert(node_type&& nh); // C++17
|
|
|
|
iterator insert(const_iterator hint, node_type&& nh); // C++17
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator erase(const_iterator position);
|
2015-05-10 21:35:00 +08:00
|
|
|
iterator erase(iterator position); // C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
size_type erase(const key_type& k);
|
|
|
|
iterator erase(const_iterator first, const_iterator last);
|
2011-06-04 23:22:34 +08:00
|
|
|
void clear() noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2018-11-01 01:31:35 +08:00
|
|
|
template<class C2>
|
|
|
|
void merge(multimap<Key, T, C2, Allocator>& source); // C++17
|
|
|
|
template<class C2>
|
|
|
|
void merge(multimap<Key, T, C2, Allocator>&& source); // C++17
|
|
|
|
template<class C2>
|
|
|
|
void merge(map<Key, T, C2, Allocator>& source); // C++17
|
|
|
|
template<class C2>
|
|
|
|
void merge(map<Key, T, C2, Allocator>&& source); // C++17
|
|
|
|
|
2011-06-04 22:31:57 +08:00
|
|
|
void swap(multimap& m)
|
2015-07-14 04:04:56 +08:00
|
|
|
noexcept(allocator_traits<allocator_type>::is_always_equal::value &&
|
2016-04-22 07:38:59 +08:00
|
|
|
is_nothrow_swappable<key_compare>::value); // C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
// observers:
|
2011-06-04 23:22:34 +08:00
|
|
|
allocator_type get_allocator() const noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
key_compare key_comp() const;
|
|
|
|
value_compare value_comp() const;
|
|
|
|
|
|
|
|
// map operations:
|
|
|
|
iterator find(const key_type& k);
|
|
|
|
const_iterator find(const key_type& k) const;
|
2013-08-14 06:18:47 +08:00
|
|
|
template<typename K>
|
|
|
|
iterator find(const K& x); // C++14
|
|
|
|
template<typename K>
|
|
|
|
const_iterator find(const K& x) const; // C++14
|
|
|
|
template<typename K>
|
2014-08-25 07:54:16 +08:00
|
|
|
size_type count(const K& x) const; // C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
size_type count(const key_type& k) const;
|
2019-07-16 11:21:01 +08:00
|
|
|
bool contains(const key_type& x) const; // C++20
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator lower_bound(const key_type& k);
|
|
|
|
const_iterator lower_bound(const key_type& k) const;
|
2013-08-14 06:18:47 +08:00
|
|
|
template<typename K>
|
|
|
|
iterator lower_bound(const K& x); // C++14
|
|
|
|
template<typename K>
|
|
|
|
const_iterator lower_bound(const K& x) const; // C++14
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator upper_bound(const key_type& k);
|
|
|
|
const_iterator upper_bound(const key_type& k) const;
|
2013-08-14 06:18:47 +08:00
|
|
|
template<typename K>
|
|
|
|
iterator upper_bound(const K& x); // C++14
|
|
|
|
template<typename K>
|
|
|
|
const_iterator upper_bound(const K& x) const; // C++14
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
pair<iterator,iterator> equal_range(const key_type& k);
|
|
|
|
pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
|
2013-08-14 06:18:47 +08:00
|
|
|
template<typename K>
|
|
|
|
pair<iterator,iterator> equal_range(const K& x); // C++14
|
|
|
|
template<typename K>
|
|
|
|
pair<const_iterator,const_iterator> equal_range(const K& x) const; // C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
template <class Key, class T, class Compare, class Allocator>
|
|
|
|
bool
|
|
|
|
operator==(const multimap<Key, T, Compare, Allocator>& x,
|
|
|
|
const multimap<Key, T, Compare, Allocator>& y);
|
|
|
|
|
|
|
|
template <class Key, class T, class Compare, class Allocator>
|
|
|
|
bool
|
|
|
|
operator< (const multimap<Key, T, Compare, Allocator>& x,
|
|
|
|
const multimap<Key, T, Compare, Allocator>& y);
|
|
|
|
|
|
|
|
template <class Key, class T, class Compare, class Allocator>
|
|
|
|
bool
|
|
|
|
operator!=(const multimap<Key, T, Compare, Allocator>& x,
|
|
|
|
const multimap<Key, T, Compare, Allocator>& y);
|
|
|
|
|
|
|
|
template <class Key, class T, class Compare, class Allocator>
|
|
|
|
bool
|
|
|
|
operator> (const multimap<Key, T, Compare, Allocator>& x,
|
|
|
|
const multimap<Key, T, Compare, Allocator>& y);
|
|
|
|
|
|
|
|
template <class Key, class T, class Compare, class Allocator>
|
|
|
|
bool
|
|
|
|
operator>=(const multimap<Key, T, Compare, Allocator>& x,
|
|
|
|
const multimap<Key, T, Compare, Allocator>& y);
|
|
|
|
|
|
|
|
template <class Key, class T, class Compare, class Allocator>
|
|
|
|
bool
|
|
|
|
operator<=(const multimap<Key, T, Compare, Allocator>& x,
|
|
|
|
const multimap<Key, T, Compare, Allocator>& y);
|
|
|
|
|
|
|
|
// specialized algorithms:
|
|
|
|
template <class Key, class T, class Compare, class Allocator>
|
|
|
|
void
|
|
|
|
swap(multimap<Key, T, Compare, Allocator>& x,
|
2011-06-04 22:31:57 +08:00
|
|
|
multimap<Key, T, Compare, Allocator>& y)
|
|
|
|
noexcept(noexcept(x.swap(y)));
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2018-12-15 02:49:35 +08:00
|
|
|
template <class Key, class T, class Compare, class Allocator, class Predicate>
|
2020-05-02 19:58:03 +08:00
|
|
|
typename multimap<Key, T, Compare, Allocator>::size_type
|
|
|
|
erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred); // C++20
|
2018-12-15 02:49:35 +08:00
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
} // std
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <__config>
|
|
|
|
#include <__tree>
|
2018-08-01 09:33:38 +08:00
|
|
|
#include <__node_handle>
|
2010-05-12 03:42:16 +08:00
|
|
|
#include <iterator>
|
|
|
|
#include <memory>
|
|
|
|
#include <utility>
|
|
|
|
#include <functional>
|
|
|
|
#include <initializer_list>
|
2015-06-13 15:08:02 +08:00
|
|
|
#include <type_traits>
|
2018-09-13 03:41:40 +08:00
|
|
|
#include <version>
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-10-18 04:05:10 +08:00
|
|
|
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
2010-05-12 03:42:16 +08:00
|
|
|
#pragma GCC system_header
|
2011-10-18 04:05:10 +08:00
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
|
2018-12-07 05:46:17 +08:00
|
|
|
template <class _Key, class _CP, class _Compare,
|
|
|
|
bool = is_empty<_Compare>::value && !__libcpp_is_final<_Compare>::value>
|
2010-05-12 03:42:16 +08:00
|
|
|
class __map_value_compare
|
|
|
|
: private _Compare
|
|
|
|
{
|
|
|
|
public:
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
__map_value_compare()
|
|
|
|
_NOEXCEPT_(is_nothrow_default_constructible<_Compare>::value)
|
|
|
|
: _Compare() {}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
__map_value_compare(_Compare c)
|
|
|
|
_NOEXCEPT_(is_nothrow_copy_constructible<_Compare>::value)
|
|
|
|
: _Compare(c) {}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
const _Compare& key_comp() const _NOEXCEPT {return *this;}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool operator()(const _CP& __x, const _CP& __y) const
|
2018-06-05 04:38:23 +08:00
|
|
|
{return static_cast<const _Compare&>(*this)(__x.__get_value().first, __y.__get_value().first);}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool operator()(const _CP& __x, const _Key& __y) const
|
2018-06-05 04:38:23 +08:00
|
|
|
{return static_cast<const _Compare&>(*this)(__x.__get_value().first, __y);}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool operator()(const _Key& __x, const _CP& __y) const
|
2018-06-05 04:38:23 +08:00
|
|
|
{return static_cast<const _Compare&>(*this)(__x, __y.__get_value().first);}
|
2015-07-14 04:04:56 +08:00
|
|
|
void swap(__map_value_compare&__y)
|
|
|
|
_NOEXCEPT_(__is_nothrow_swappable<_Compare>::value)
|
|
|
|
{
|
2017-04-13 08:34:24 +08:00
|
|
|
using _VSTD::swap;
|
|
|
|
swap(static_cast<_Compare&>(*this), static_cast<_Compare&>(__y));
|
2015-07-14 04:04:56 +08:00
|
|
|
}
|
2013-08-14 06:18:47 +08:00
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
|
|
|
|
operator () ( const _K2& __x, const _CP& __y ) const
|
2018-06-05 04:38:23 +08:00
|
|
|
{return static_cast<const _Compare&>(*this) (__x, __y.__get_value().first);}
|
2013-08-14 06:18:47 +08:00
|
|
|
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
|
|
|
|
operator () (const _CP& __x, const _K2& __y) const
|
2018-06-05 04:38:23 +08:00
|
|
|
{return static_cast<const _Compare&>(*this) (__x.__get_value().first, __y);}
|
2013-08-14 06:18:47 +08:00
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
2013-07-06 02:06:00 +08:00
|
|
|
template <class _Key, class _CP, class _Compare>
|
|
|
|
class __map_value_compare<_Key, _CP, _Compare, false>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
_Compare comp;
|
|
|
|
|
|
|
|
public:
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
__map_value_compare()
|
|
|
|
_NOEXCEPT_(is_nothrow_default_constructible<_Compare>::value)
|
|
|
|
: comp() {}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
__map_value_compare(_Compare c)
|
|
|
|
_NOEXCEPT_(is_nothrow_copy_constructible<_Compare>::value)
|
|
|
|
: comp(c) {}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
const _Compare& key_comp() const _NOEXCEPT {return comp;}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool operator()(const _CP& __x, const _CP& __y) const
|
2018-06-05 04:38:23 +08:00
|
|
|
{return comp(__x.__get_value().first, __y.__get_value().first);}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool operator()(const _CP& __x, const _Key& __y) const
|
2018-06-05 04:38:23 +08:00
|
|
|
{return comp(__x.__get_value().first, __y);}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool operator()(const _Key& __x, const _CP& __y) const
|
2018-06-05 04:38:23 +08:00
|
|
|
{return comp(__x, __y.__get_value().first);}
|
2015-07-14 04:04:56 +08:00
|
|
|
void swap(__map_value_compare&__y)
|
|
|
|
_NOEXCEPT_(__is_nothrow_swappable<_Compare>::value)
|
|
|
|
{
|
|
|
|
using _VSTD::swap;
|
|
|
|
swap(comp, __y.comp);
|
|
|
|
}
|
2017-01-05 14:06:18 +08:00
|
|
|
|
2013-08-14 06:18:47 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
|
|
|
|
operator () ( const _K2& __x, const _CP& __y ) const
|
2018-06-05 04:38:23 +08:00
|
|
|
{return comp (__x, __y.__get_value().first);}
|
2013-08-14 06:18:47 +08:00
|
|
|
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
|
|
|
|
operator () (const _CP& __x, const _K2& __y) const
|
2018-06-05 04:38:23 +08:00
|
|
|
{return comp (__x.__get_value().first, __y);}
|
2013-08-14 06:18:47 +08:00
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
2015-07-14 04:04:56 +08:00
|
|
|
template <class _Key, class _CP, class _Compare, bool __b>
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
void
|
|
|
|
swap(__map_value_compare<_Key, _CP, _Compare, __b>& __x,
|
|
|
|
__map_value_compare<_Key, _CP, _Compare, __b>& __y)
|
|
|
|
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
|
|
|
|
{
|
|
|
|
__x.swap(__y);
|
|
|
|
}
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Allocator>
|
|
|
|
class __map_node_destructor
|
|
|
|
{
|
|
|
|
typedef _Allocator allocator_type;
|
|
|
|
typedef allocator_traits<allocator_type> __alloc_traits;
|
2016-02-20 13:28:30 +08:00
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
public:
|
|
|
|
typedef typename __alloc_traits::pointer pointer;
|
|
|
|
|
2016-02-20 13:28:30 +08:00
|
|
|
private:
|
2010-05-12 03:42:16 +08:00
|
|
|
allocator_type& __na_;
|
|
|
|
|
|
|
|
__map_node_destructor& operator=(const __map_node_destructor&);
|
|
|
|
|
|
|
|
public:
|
|
|
|
bool __first_constructed;
|
|
|
|
bool __second_constructed;
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
explicit __map_node_destructor(allocator_type& __na) _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
: __na_(__na),
|
|
|
|
__first_constructed(false),
|
|
|
|
__second_constructed(false)
|
|
|
|
{}
|
|
|
|
|
2017-04-19 05:08:06 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
__map_node_destructor(__tree_node_destructor<allocator_type>&& __x) _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
: __na_(__x.__na_),
|
|
|
|
__first_constructed(__x.__value_constructed),
|
|
|
|
__second_constructed(__x.__value_constructed)
|
|
|
|
{
|
|
|
|
__x.__value_constructed = false;
|
|
|
|
}
|
2017-04-19 05:08:06 +08:00
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
void operator()(pointer __p) _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
if (__second_constructed)
|
2018-06-05 04:38:23 +08:00
|
|
|
__alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().second));
|
2010-05-12 03:42:16 +08:00
|
|
|
if (__first_constructed)
|
2018-06-05 04:38:23 +08:00
|
|
|
__alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().first));
|
2010-05-12 03:42:16 +08:00
|
|
|
if (__p)
|
|
|
|
__alloc_traits::deallocate(__na_, __p, 1);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-06-15 03:58:17 +08:00
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
|
|
|
class map;
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
|
|
|
class multimap;
|
|
|
|
template <class _TreeIterator> class __map_const_iterator;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2016-02-20 13:28:30 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2013-10-01 03:08:22 +08:00
|
|
|
|
|
|
|
template <class _Key, class _Tp>
|
2018-06-05 04:38:23 +08:00
|
|
|
struct __value_type
|
2013-10-01 03:08:22 +08:00
|
|
|
{
|
|
|
|
typedef _Key key_type;
|
|
|
|
typedef _Tp mapped_type;
|
|
|
|
typedef pair<const key_type, mapped_type> value_type;
|
2018-06-05 04:38:23 +08:00
|
|
|
typedef pair<key_type&, mapped_type&> __nc_ref_pair_type;
|
|
|
|
typedef pair<key_type&&, mapped_type&&> __nc_rref_pair_type;
|
2013-10-01 03:08:22 +08:00
|
|
|
|
2018-06-05 04:38:23 +08:00
|
|
|
private:
|
2013-10-01 03:08:22 +08:00
|
|
|
value_type __cc;
|
2018-06-05 04:38:23 +08:00
|
|
|
|
|
|
|
public:
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
value_type& __get_value()
|
|
|
|
{
|
|
|
|
#if _LIBCPP_STD_VER > 14
|
|
|
|
return *_VSTD::launder(_VSTD::addressof(__cc));
|
|
|
|
#else
|
|
|
|
return __cc;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
const value_type& __get_value() const
|
|
|
|
{
|
|
|
|
#if _LIBCPP_STD_VER > 14
|
|
|
|
return *_VSTD::launder(_VSTD::addressof(__cc));
|
|
|
|
#else
|
|
|
|
return __cc;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
__nc_ref_pair_type __ref()
|
|
|
|
{
|
|
|
|
value_type& __v = __get_value();
|
|
|
|
return __nc_ref_pair_type(const_cast<key_type&>(__v.first), __v.second);
|
|
|
|
}
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
__nc_rref_pair_type __move()
|
|
|
|
{
|
|
|
|
value_type& __v = __get_value();
|
|
|
|
return __nc_rref_pair_type(
|
|
|
|
_VSTD::move(const_cast<key_type&>(__v.first)),
|
|
|
|
_VSTD::move(__v.second));
|
|
|
|
}
|
2013-10-01 03:08:22 +08:00
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
__value_type& operator=(const __value_type& __v)
|
2018-06-05 04:38:23 +08:00
|
|
|
{
|
|
|
|
__ref() = __v.__get_value();
|
|
|
|
return *this;
|
|
|
|
}
|
2013-10-01 03:08:22 +08:00
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
__value_type& operator=(__value_type&& __v)
|
2018-06-05 04:38:23 +08:00
|
|
|
{
|
|
|
|
__ref() = __v.__move();
|
|
|
|
return *this;
|
|
|
|
}
|
2013-10-01 03:08:22 +08:00
|
|
|
|
2016-03-31 10:15:15 +08:00
|
|
|
template <class _ValueTp,
|
|
|
|
class = typename enable_if<
|
|
|
|
__is_same_uncvref<_ValueTp, value_type>::value
|
|
|
|
>::type
|
|
|
|
>
|
2013-10-01 03:08:22 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-06-05 04:38:23 +08:00
|
|
|
__value_type& operator=(_ValueTp&& __v)
|
|
|
|
{
|
|
|
|
__ref() = _VSTD::forward<_ValueTp>(__v);
|
|
|
|
return *this;
|
2016-03-31 10:15:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
__value_type() _LIBCPP_EQUAL_DELETE;
|
|
|
|
~__value_type() _LIBCPP_EQUAL_DELETE;
|
|
|
|
__value_type(const __value_type& __v) _LIBCPP_EQUAL_DELETE;
|
|
|
|
__value_type(__value_type&& __v) _LIBCPP_EQUAL_DELETE;
|
2013-10-01 03:08:22 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
template <class _Key, class _Tp>
|
|
|
|
struct __value_type
|
|
|
|
{
|
|
|
|
typedef _Key key_type;
|
|
|
|
typedef _Tp mapped_type;
|
|
|
|
typedef pair<const key_type, mapped_type> value_type;
|
|
|
|
|
2018-06-05 04:38:23 +08:00
|
|
|
private:
|
2013-10-01 03:08:22 +08:00
|
|
|
value_type __cc;
|
|
|
|
|
2018-06-05 04:38:23 +08:00
|
|
|
public:
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
value_type& __get_value() { return __cc; }
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
const value_type& __get_value() const { return __cc; }
|
|
|
|
|
2016-03-31 10:15:15 +08:00
|
|
|
private:
|
|
|
|
__value_type();
|
|
|
|
__value_type(__value_type const&);
|
|
|
|
__value_type& operator=(__value_type const&);
|
|
|
|
~__value_type();
|
2013-10-01 03:08:22 +08:00
|
|
|
};
|
|
|
|
|
2017-04-19 05:08:06 +08:00
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
2013-10-01 03:08:22 +08:00
|
|
|
|
2015-03-04 04:10:01 +08:00
|
|
|
template <class _Tp>
|
|
|
|
struct __extract_key_value_types;
|
|
|
|
|
|
|
|
template <class _Key, class _Tp>
|
|
|
|
struct __extract_key_value_types<__value_type<_Key, _Tp> >
|
|
|
|
{
|
|
|
|
typedef _Key const __key_type;
|
|
|
|
typedef _Tp __mapped_type;
|
|
|
|
};
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _TreeIterator>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS __map_iterator
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2016-02-20 13:28:30 +08:00
|
|
|
typedef typename _TreeIterator::_NodeTypes _NodeTypes;
|
|
|
|
typedef typename _TreeIterator::__pointer_traits __pointer_traits;
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
_TreeIterator __i_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
typedef bidirectional_iterator_tag iterator_category;
|
2016-02-20 13:28:30 +08:00
|
|
|
typedef typename _NodeTypes::__map_value_type value_type;
|
2010-05-12 03:42:16 +08:00
|
|
|
typedef typename _TreeIterator::difference_type difference_type;
|
|
|
|
typedef value_type& reference;
|
2016-02-20 13:28:30 +08:00
|
|
|
typedef typename _NodeTypes::__map_value_type_pointer pointer;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
__map_iterator() _NOEXCEPT {}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
__map_iterator(_TreeIterator __i) _NOEXCEPT : __i_(__i) {}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-06-05 04:38:23 +08:00
|
|
|
reference operator*() const {return __i_->__get_value();}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-06-05 04:38:23 +08:00
|
|
|
pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__get_value());}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
__map_iterator& operator++() {++__i_; return *this;}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
__map_iterator operator++(int)
|
|
|
|
{
|
|
|
|
__map_iterator __t(*this);
|
|
|
|
++(*this);
|
|
|
|
return __t;
|
|
|
|
}
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
__map_iterator& operator--() {--__i_; return *this;}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
__map_iterator operator--(int)
|
|
|
|
{
|
|
|
|
__map_iterator __t(*this);
|
|
|
|
--(*this);
|
|
|
|
return __t;
|
|
|
|
}
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
friend _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator==(const __map_iterator& __x, const __map_iterator& __y)
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x.__i_ == __y.__i_;}
|
2017-01-05 14:06:18 +08:00
|
|
|
friend
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator!=(const __map_iterator& __x, const __map_iterator& __y)
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x.__i_ != __y.__i_;}
|
|
|
|
|
2017-01-05 07:56:00 +08:00
|
|
|
template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
|
|
|
|
template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
|
|
|
|
template <class> friend class _LIBCPP_TEMPLATE_VIS __map_const_iterator;
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
template <class _TreeIterator>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS __map_const_iterator
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2016-02-20 13:28:30 +08:00
|
|
|
typedef typename _TreeIterator::_NodeTypes _NodeTypes;
|
|
|
|
typedef typename _TreeIterator::__pointer_traits __pointer_traits;
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
_TreeIterator __i_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
typedef bidirectional_iterator_tag iterator_category;
|
2016-02-20 13:28:30 +08:00
|
|
|
typedef typename _NodeTypes::__map_value_type value_type;
|
2010-05-12 03:42:16 +08:00
|
|
|
typedef typename _TreeIterator::difference_type difference_type;
|
|
|
|
typedef const value_type& reference;
|
2016-02-20 13:28:30 +08:00
|
|
|
typedef typename _NodeTypes::__const_map_value_type_pointer pointer;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
__map_const_iterator() _NOEXCEPT {}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
__map_const_iterator(_TreeIterator __i) _NOEXCEPT : __i_(__i) {}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2015-03-04 04:10:01 +08:00
|
|
|
__map_const_iterator(__map_iterator<
|
|
|
|
typename _TreeIterator::__non_const_iterator> __i) _NOEXCEPT
|
|
|
|
: __i_(__i.__i_) {}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-06-05 04:38:23 +08:00
|
|
|
reference operator*() const {return __i_->__get_value();}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-06-05 04:38:23 +08:00
|
|
|
pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__get_value());}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
__map_const_iterator& operator++() {++__i_; return *this;}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
__map_const_iterator operator++(int)
|
|
|
|
{
|
|
|
|
__map_const_iterator __t(*this);
|
|
|
|
++(*this);
|
|
|
|
return __t;
|
|
|
|
}
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
__map_const_iterator& operator--() {--__i_; return *this;}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
__map_const_iterator operator--(int)
|
|
|
|
{
|
|
|
|
__map_const_iterator __t(*this);
|
|
|
|
--(*this);
|
|
|
|
return __t;
|
|
|
|
}
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
friend _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator==(const __map_const_iterator& __x, const __map_const_iterator& __y)
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x.__i_ == __y.__i_;}
|
2010-09-23 00:48:34 +08:00
|
|
|
friend _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator!=(const __map_const_iterator& __x, const __map_const_iterator& __y)
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x.__i_ != __y.__i_;}
|
|
|
|
|
2017-01-05 07:56:00 +08:00
|
|
|
template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
|
|
|
|
template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
|
|
|
|
template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS __tree_const_iterator;
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare = less<_Key>,
|
|
|
|
class _Allocator = allocator<pair<const _Key, _Tp> > >
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS map
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
// types:
|
|
|
|
typedef _Key key_type;
|
|
|
|
typedef _Tp mapped_type;
|
|
|
|
typedef pair<const key_type, mapped_type> value_type;
|
2019-06-21 03:32:00 +08:00
|
|
|
typedef typename __identity<_Compare>::type key_compare;
|
|
|
|
typedef typename __identity<_Allocator>::type allocator_type;
|
2010-05-12 03:42:16 +08:00
|
|
|
typedef value_type& reference;
|
|
|
|
typedef const value_type& const_reference;
|
|
|
|
|
2015-11-26 09:24:04 +08:00
|
|
|
static_assert((is_same<typename allocator_type::value_type, value_type>::value),
|
|
|
|
"Allocator::value_type must be same type as value_type");
|
|
|
|
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS value_compare
|
2010-05-12 03:42:16 +08:00
|
|
|
: public binary_function<value_type, value_type, bool>
|
|
|
|
{
|
|
|
|
friend class map;
|
|
|
|
protected:
|
|
|
|
key_compare comp;
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY value_compare(key_compare c) : comp(c) {}
|
2010-05-12 03:42:16 +08:00
|
|
|
public:
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool operator()(const value_type& __x, const value_type& __y) const
|
|
|
|
{return comp(__x.first, __y.first);}
|
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
2013-06-20 05:29:40 +08:00
|
|
|
|
2013-10-01 03:08:22 +08:00
|
|
|
typedef _VSTD::__value_type<key_type, mapped_type> __value_type;
|
2013-07-06 02:06:00 +08:00
|
|
|
typedef __map_value_compare<key_type, __value_type, key_compare> __vc;
|
2015-04-07 13:21:38 +08:00
|
|
|
typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>,
|
|
|
|
__value_type>::type __allocator_type;
|
2010-05-12 03:42:16 +08:00
|
|
|
typedef __tree<__value_type, __vc, __allocator_type> __base;
|
|
|
|
typedef typename __base::__node_traits __node_traits;
|
|
|
|
typedef allocator_traits<allocator_type> __alloc_traits;
|
|
|
|
|
|
|
|
__base __tree_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
typedef typename __alloc_traits::pointer pointer;
|
|
|
|
typedef typename __alloc_traits::const_pointer const_pointer;
|
|
|
|
typedef typename __alloc_traits::size_type size_type;
|
|
|
|
typedef typename __alloc_traits::difference_type difference_type;
|
2015-03-04 04:10:01 +08:00
|
|
|
typedef __map_iterator<typename __base::iterator> iterator;
|
2010-05-12 03:42:16 +08:00
|
|
|
typedef __map_const_iterator<typename __base::const_iterator> const_iterator;
|
2011-07-01 05:18:19 +08:00
|
|
|
typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
|
|
|
|
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2018-08-01 09:33:38 +08:00
|
|
|
#if _LIBCPP_STD_VER > 14
|
|
|
|
typedef __map_node_handle<typename __base::__node, allocator_type> node_type;
|
|
|
|
typedef __insert_return_type<iterator, node_type> insert_return_type;
|
|
|
|
#endif
|
|
|
|
|
2018-11-01 01:31:35 +08:00
|
|
|
template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
|
|
|
|
friend class _LIBCPP_TEMPLATE_VIS map;
|
|
|
|
template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
|
|
|
|
friend class _LIBCPP_TEMPLATE_VIS multimap;
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2014-03-10 12:50:10 +08:00
|
|
|
map()
|
|
|
|
_NOEXCEPT_(
|
|
|
|
is_nothrow_default_constructible<allocator_type>::value &&
|
|
|
|
is_nothrow_default_constructible<key_compare>::value &&
|
|
|
|
is_nothrow_copy_constructible<key_compare>::value)
|
|
|
|
: __tree_(__vc(key_compare())) {}
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
explicit map(const key_compare& __comp)
|
2011-06-04 22:31:57 +08:00
|
|
|
_NOEXCEPT_(
|
|
|
|
is_nothrow_default_constructible<allocator_type>::value &&
|
|
|
|
is_nothrow_copy_constructible<key_compare>::value)
|
2010-05-12 03:42:16 +08:00
|
|
|
: __tree_(__vc(__comp)) {}
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
explicit map(const key_compare& __comp, const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __tree_(__vc(__comp), typename __base::allocator_type(__a)) {}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
template <class _InputIterator>
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
map(_InputIterator __f, _InputIterator __l,
|
|
|
|
const key_compare& __comp = key_compare())
|
|
|
|
: __tree_(__vc(__comp))
|
|
|
|
{
|
|
|
|
insert(__f, __l);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _InputIterator>
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
map(_InputIterator __f, _InputIterator __l,
|
|
|
|
const key_compare& __comp, const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __tree_(__vc(__comp), typename __base::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
insert(__f, __l);
|
|
|
|
}
|
|
|
|
|
2013-09-11 09:15:47 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _InputIterator>
|
2017-01-05 14:06:18 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2013-09-11 09:15:47 +08:00
|
|
|
map(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
|
|
|
|
: map(__f, __l, key_compare(), __a) {}
|
|
|
|
#endif
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
map(const map& __m)
|
|
|
|
: __tree_(__m.__tree_)
|
|
|
|
{
|
|
|
|
insert(__m.begin(), __m.end());
|
|
|
|
}
|
|
|
|
|
2011-07-02 03:24:36 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
map& operator=(const map& __m)
|
|
|
|
{
|
2016-07-18 21:19:00 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2011-07-02 03:24:36 +08:00
|
|
|
__tree_ = __m.__tree_;
|
2013-06-20 05:29:40 +08:00
|
|
|
#else
|
2014-02-08 12:03:14 +08:00
|
|
|
if (this != &__m) {
|
|
|
|
__tree_.clear();
|
|
|
|
__tree_.value_comp() = __m.__tree_.value_comp();
|
|
|
|
__tree_.__copy_assign_alloc(__m.__tree_);
|
|
|
|
insert(__m.begin(), __m.end());
|
|
|
|
}
|
2013-06-20 05:29:40 +08:00
|
|
|
#endif
|
2011-07-02 03:24:36 +08:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2017-04-19 05:08:06 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
map(map&& __m)
|
2011-06-04 22:31:57 +08:00
|
|
|
_NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
|
2011-07-01 05:18:19 +08:00
|
|
|
: __tree_(_VSTD::move(__m.__tree_))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
map(map&& __m, const allocator_type& __a);
|
|
|
|
|
2011-08-13 05:56:02 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
map& operator=(map&& __m)
|
|
|
|
_NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
|
|
|
|
{
|
|
|
|
__tree_ = _VSTD::move(__m.__tree_);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
map(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
|
|
|
|
: __tree_(__vc(__comp))
|
|
|
|
{
|
|
|
|
insert(__il.begin(), __il.end());
|
|
|
|
}
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
map(initializer_list<value_type> __il, const key_compare& __comp, const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __tree_(__vc(__comp), typename __base::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
insert(__il.begin(), __il.end());
|
|
|
|
}
|
|
|
|
|
2013-09-11 09:15:47 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
2017-01-05 14:06:18 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2013-09-11 09:15:47 +08:00
|
|
|
map(initializer_list<value_type> __il, const allocator_type& __a)
|
|
|
|
: map(__il, key_compare(), __a) {}
|
|
|
|
#endif
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
map& operator=(initializer_list<value_type> __il)
|
|
|
|
{
|
|
|
|
__tree_.__assign_unique(__il.begin(), __il.end());
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2017-04-19 05:08:06 +08:00
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
explicit map(const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __tree_(typename __base::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
map(const map& __m, const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __tree_(__m.__tree_.value_comp(), typename __base::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
insert(__m.begin(), __m.end());
|
|
|
|
}
|
|
|
|
|
[libc++] Make sure we don't eagerly diagnose non-const comparators for containers of incomplete types
Summary:
In r348529, I improved the library-defined diagnostic for using containers
with a non-const comparator/hasher. However, the check is now performed
too early, which leads to the diagnostic being emitted in cases where it
shouldn't. See PR41360 for details.
This patch moves the diagnostic to the destructor of the containers, which
means that the diagnostic will only be emitted when the container is instantiated
at a point where the comparator and the key/value are required to be complete.
We still retain better diagnostics than before r348529, because the diagnostics
are performed in the containers themselves instead of __tree and __hash_table.
As a drive-by fix, I improved the diagnostic to mention that we can't find
a _viable_ const call operator, as suggested by EricWF in PR41360.
Reviewers: EricWF, mclow.lists
Subscribers: christof, jkorous, dexonsmith, libcxx-commits, zoecarver
Tags: #libc
Differential Revision: https://reviews.llvm.org/D60540
llvm-svn: 358189
2019-04-12 00:14:56 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
~map() {
|
|
|
|
static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), "");
|
|
|
|
}
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
iterator begin() _NOEXCEPT {return __tree_.begin();}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
const_iterator begin() const _NOEXCEPT {return __tree_.begin();}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
iterator end() _NOEXCEPT {return __tree_.end();}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
const_iterator end() const _NOEXCEPT {return __tree_.end();}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
const_reverse_iterator rbegin() const _NOEXCEPT
|
|
|
|
{return const_reverse_iterator(end());}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
reverse_iterator rend() _NOEXCEPT
|
|
|
|
{return reverse_iterator(begin());}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
const_reverse_iterator rend() const _NOEXCEPT
|
|
|
|
{return const_reverse_iterator(begin());}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
const_iterator cbegin() const _NOEXCEPT {return begin();}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
const_iterator cend() const _NOEXCEPT {return end();}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
const_reverse_iterator crend() const _NOEXCEPT {return rend();}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2017-11-15 13:51:26 +08:00
|
|
|
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
bool empty() const _NOEXCEPT {return __tree_.size() == 0;}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
size_type size() const _NOEXCEPT {return __tree_.size();}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
size_type max_size() const _NOEXCEPT {return __tree_.max_size();}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
mapped_type& operator[](const key_type& __k);
|
2016-03-31 11:13:37 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
mapped_type& operator[](key_type&& __k);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
mapped_type& at(const key_type& __k);
|
|
|
|
const mapped_type& at(const key_type& __k) const;
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2016-08-17 13:58:40 +08:00
|
|
|
allocator_type get_allocator() const _NOEXCEPT {return allocator_type(__tree_.__alloc());}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
key_compare key_comp() const {return __tree_.value_comp().key_comp();}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
value_compare value_comp() const {return value_compare(__tree_.value_comp().key_comp());}
|
|
|
|
|
2016-03-31 10:15:15 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2012-05-26 06:04:21 +08:00
|
|
|
template <class ..._Args>
|
2016-03-31 10:15:15 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
pair<iterator, bool> emplace(_Args&& ...__args) {
|
|
|
|
return __tree_.__emplace_unique(_VSTD::forward<_Args>(__args)...);
|
|
|
|
}
|
2010-09-05 07:28:19 +08:00
|
|
|
|
2012-05-26 06:04:21 +08:00
|
|
|
template <class ..._Args>
|
2016-03-31 10:15:15 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator emplace_hint(const_iterator __p, _Args&& ...__args) {
|
|
|
|
return __tree_.__emplace_hint_unique(__p.__i_, _VSTD::forward<_Args>(__args)...);
|
|
|
|
}
|
2010-09-05 07:28:19 +08:00
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template <class _Pp,
|
|
|
|
class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-11-30 02:15:50 +08:00
|
|
|
pair<iterator, bool> insert(_Pp&& __p)
|
|
|
|
{return __tree_.__insert_unique(_VSTD::forward<_Pp>(__p));}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template <class _Pp,
|
|
|
|
class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-11-30 02:15:50 +08:00
|
|
|
iterator insert(const_iterator __pos, _Pp&& __p)
|
|
|
|
{return __tree_.__insert_unique(__pos.__i_, _VSTD::forward<_Pp>(__p));}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2016-03-31 10:15:15 +08:00
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
pair<iterator, bool>
|
|
|
|
insert(const value_type& __v) {return __tree_.__insert_unique(__v);}
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator
|
|
|
|
insert(const_iterator __p, const value_type& __v)
|
|
|
|
{return __tree_.__insert_unique(__p.__i_, __v);}
|
|
|
|
|
2016-04-18 09:40:45 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2016-01-06 03:32:41 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
pair<iterator, bool>
|
2016-03-31 10:15:15 +08:00
|
|
|
insert(value_type&& __v) {return __tree_.__insert_unique(_VSTD::move(__v));}
|
2016-01-06 03:32:41 +08:00
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2016-03-31 10:15:15 +08:00
|
|
|
iterator insert(const_iterator __p, value_type&& __v)
|
|
|
|
{return __tree_.__insert_unique(__p.__i_, _VSTD::move(__v));}
|
2017-04-19 05:08:06 +08:00
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
void insert(initializer_list<value_type> __il)
|
|
|
|
{insert(__il.begin(), __il.end());}
|
2016-01-06 03:32:41 +08:00
|
|
|
#endif
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _InputIterator>
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
void insert(_InputIterator __f, _InputIterator __l)
|
|
|
|
{
|
|
|
|
for (const_iterator __e = cend(); __f != __l; ++__f)
|
|
|
|
insert(__e.__i_, *__f);
|
|
|
|
}
|
|
|
|
|
2015-07-07 11:37:33 +08:00
|
|
|
#if _LIBCPP_STD_VER > 14
|
2016-03-31 11:13:37 +08:00
|
|
|
|
2015-07-07 11:37:33 +08:00
|
|
|
template <class... _Args>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args)
|
|
|
|
{
|
2016-03-31 11:13:37 +08:00
|
|
|
return __tree_.__emplace_unique_key_args(__k,
|
|
|
|
_VSTD::piecewise_construct,
|
|
|
|
_VSTD::forward_as_tuple(__k),
|
|
|
|
_VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
|
2015-07-07 11:37:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class... _Args>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
pair<iterator, bool> try_emplace(key_type&& __k, _Args&&... __args)
|
|
|
|
{
|
2016-03-31 11:13:37 +08:00
|
|
|
return __tree_.__emplace_unique_key_args(__k,
|
|
|
|
_VSTD::piecewise_construct,
|
|
|
|
_VSTD::forward_as_tuple(_VSTD::move(__k)),
|
|
|
|
_VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
|
2015-07-07 11:37:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class... _Args>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator try_emplace(const_iterator __h, const key_type& __k, _Args&&... __args)
|
|
|
|
{
|
2016-03-31 11:13:37 +08:00
|
|
|
return __tree_.__emplace_hint_unique_key_args(__h.__i_, __k,
|
|
|
|
_VSTD::piecewise_construct,
|
|
|
|
_VSTD::forward_as_tuple(__k),
|
|
|
|
_VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
|
2015-07-07 11:37:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class... _Args>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator try_emplace(const_iterator __h, key_type&& __k, _Args&&... __args)
|
|
|
|
{
|
2016-03-31 11:13:37 +08:00
|
|
|
return __tree_.__emplace_hint_unique_key_args(__h.__i_, __k,
|
|
|
|
_VSTD::piecewise_construct,
|
|
|
|
_VSTD::forward_as_tuple(_VSTD::move(__k)),
|
|
|
|
_VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
|
2015-07-07 11:37:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Vp>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
pair<iterator, bool> insert_or_assign(const key_type& __k, _Vp&& __v)
|
|
|
|
{
|
|
|
|
iterator __p = lower_bound(__k);
|
|
|
|
if ( __p != end() && !key_comp()(__k, __p->first))
|
|
|
|
{
|
|
|
|
__p->second = _VSTD::forward<_Vp>(__v);
|
|
|
|
return _VSTD::make_pair(__p, false);
|
|
|
|
}
|
|
|
|
return _VSTD::make_pair(emplace_hint(__p, __k, _VSTD::forward<_Vp>(__v)), true);
|
|
|
|
}
|
2016-03-31 11:13:37 +08:00
|
|
|
|
2015-07-07 11:37:33 +08:00
|
|
|
template <class _Vp>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
pair<iterator, bool> insert_or_assign(key_type&& __k, _Vp&& __v)
|
|
|
|
{
|
|
|
|
iterator __p = lower_bound(__k);
|
|
|
|
if ( __p != end() && !key_comp()(__k, __p->first))
|
|
|
|
{
|
|
|
|
__p->second = _VSTD::forward<_Vp>(__v);
|
|
|
|
return _VSTD::make_pair(__p, false);
|
|
|
|
}
|
|
|
|
return _VSTD::make_pair(emplace_hint(__p, _VSTD::move(__k), _VSTD::forward<_Vp>(__v)), true);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Vp>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator insert_or_assign(const_iterator __h, const key_type& __k, _Vp&& __v)
|
|
|
|
{
|
|
|
|
iterator __p = lower_bound(__k);
|
|
|
|
if ( __p != end() && !key_comp()(__k, __p->first))
|
|
|
|
{
|
|
|
|
__p->second = _VSTD::forward<_Vp>(__v);
|
|
|
|
return __p;
|
|
|
|
}
|
|
|
|
return emplace_hint(__h, __k, _VSTD::forward<_Vp>(__v));
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Vp>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator insert_or_assign(const_iterator __h, key_type&& __k, _Vp&& __v)
|
|
|
|
{
|
|
|
|
iterator __p = lower_bound(__k);
|
|
|
|
if ( __p != end() && !key_comp()(__k, __p->first))
|
|
|
|
{
|
|
|
|
__p->second = _VSTD::forward<_Vp>(__v);
|
|
|
|
return __p;
|
|
|
|
}
|
|
|
|
return emplace_hint(__h, _VSTD::move(__k), _VSTD::forward<_Vp>(__v));
|
|
|
|
}
|
2016-03-31 11:13:37 +08:00
|
|
|
|
2017-04-19 05:08:06 +08:00
|
|
|
#endif // _LIBCPP_STD_VER > 14
|
2015-07-07 11:37:33 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator erase(const_iterator __p) {return __tree_.erase(__p.__i_);}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2015-05-10 21:35:00 +08:00
|
|
|
iterator erase(iterator __p) {return __tree_.erase(__p.__i_);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
size_type erase(const key_type& __k)
|
|
|
|
{return __tree_.__erase_unique(__k);}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator erase(const_iterator __f, const_iterator __l)
|
|
|
|
{return __tree_.erase(__f.__i_, __l.__i_);}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
void clear() _NOEXCEPT {__tree_.clear();}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2018-08-01 09:33:38 +08:00
|
|
|
#if _LIBCPP_STD_VER > 14
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
insert_return_type insert(node_type&& __nh)
|
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
|
|
|
|
"node_type with incompatible allocator passed to map::insert()");
|
|
|
|
return __tree_.template __node_handle_insert_unique<
|
|
|
|
node_type, insert_return_type>(_VSTD::move(__nh));
|
|
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator insert(const_iterator __hint, node_type&& __nh)
|
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
|
|
|
|
"node_type with incompatible allocator passed to map::insert()");
|
|
|
|
return __tree_.template __node_handle_insert_unique<node_type>(
|
|
|
|
__hint.__i_, _VSTD::move(__nh));
|
|
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
node_type extract(key_type const& __key)
|
|
|
|
{
|
|
|
|
return __tree_.template __node_handle_extract<node_type>(__key);
|
|
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
node_type extract(const_iterator __it)
|
|
|
|
{
|
|
|
|
return __tree_.template __node_handle_extract<node_type>(__it.__i_);
|
|
|
|
}
|
2018-11-01 22:41:37 +08:00
|
|
|
template <class _Compare2>
|
2018-11-01 01:31:35 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-11-01 22:41:37 +08:00
|
|
|
void merge(map<key_type, mapped_type, _Compare2, allocator_type>& __source)
|
2018-11-01 01:31:35 +08:00
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
|
|
|
|
"merging container with incompatible allocator");
|
|
|
|
__tree_.__node_handle_merge_unique(__source.__tree_);
|
|
|
|
}
|
2018-11-01 22:41:37 +08:00
|
|
|
template <class _Compare2>
|
2018-11-01 01:31:35 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-11-01 22:41:37 +08:00
|
|
|
void merge(map<key_type, mapped_type, _Compare2, allocator_type>&& __source)
|
2018-11-01 01:31:35 +08:00
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
|
|
|
|
"merging container with incompatible allocator");
|
|
|
|
__tree_.__node_handle_merge_unique(__source.__tree_);
|
|
|
|
}
|
2018-11-01 22:41:37 +08:00
|
|
|
template <class _Compare2>
|
2018-11-01 01:31:35 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-11-01 22:41:37 +08:00
|
|
|
void merge(multimap<key_type, mapped_type, _Compare2, allocator_type>& __source)
|
2018-11-01 01:31:35 +08:00
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
|
|
|
|
"merging container with incompatible allocator");
|
|
|
|
__tree_.__node_handle_merge_unique(__source.__tree_);
|
|
|
|
}
|
2018-11-01 22:41:37 +08:00
|
|
|
template <class _Compare2>
|
2018-11-01 01:31:35 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-11-01 22:41:37 +08:00
|
|
|
void merge(multimap<key_type, mapped_type, _Compare2, allocator_type>&& __source)
|
2018-11-01 01:31:35 +08:00
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
|
|
|
|
"merging container with incompatible allocator");
|
|
|
|
__tree_.__node_handle_merge_unique(__source.__tree_);
|
|
|
|
}
|
2018-08-01 09:33:38 +08:00
|
|
|
#endif
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
void swap(map& __m)
|
|
|
|
_NOEXCEPT_(__is_nothrow_swappable<__base>::value)
|
|
|
|
{__tree_.swap(__m.__tree_);}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator find(const key_type& __k) {return __tree_.find(__k);}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
|
2013-08-14 06:18:47 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
|
|
|
|
find(const _K2& __k) {return __tree_.find(__k);}
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
|
|
|
|
find(const _K2& __k) const {return __tree_.find(__k);}
|
|
|
|
#endif
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
size_type count(const key_type& __k) const
|
|
|
|
{return __tree_.__count_unique(__k);}
|
2014-08-25 07:54:16 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type
|
Use multi-key tree search for {map, set}::{count, equal_range}
Patch from ngolovliov@gmail.com
Reviewed as: https://reviews.llvm.org/D42344
As described in llvm.org/PR30959, the current
implementation of std::{map, key}::{count, equal_range} in libcxx is
non-conforming. Quoting the C++14 standard [associative.reqmts]p3
> The phrase “equivalence of keys” means the equivalence relation imposed by
> the comparison and not the operator== on keys. That is, two keys k1 and k2 are
> considered to be equivalent if for the comparison object comp,
> comp(k1, k2) == false && comp(k2, k1) == false.
In the same section, the requirements table states the following:
> a.equal_range(k) equivalent to make_pair(a.lower_bound(k), a.upper_bound(k))
> a.count(k) returns the number of elements with key equivalent to k
The behaviour of libstdc++ seems to conform to the standard here.
llvm-svn: 324799
2018-02-10 10:53:47 +08:00
|
|
|
count(const _K2& __k) const {return __tree_.__count_multi(__k);}
|
2014-08-25 07:54:16 +08:00
|
|
|
#endif
|
2019-07-16 11:21:01 +08:00
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 17
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool contains(const key_type& __k) const {return find(__k) != end();}
|
|
|
|
#endif // _LIBCPP_STD_VER > 17
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator lower_bound(const key_type& __k)
|
|
|
|
{return __tree_.lower_bound(__k);}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
const_iterator lower_bound(const key_type& __k) const
|
|
|
|
{return __tree_.lower_bound(__k);}
|
2013-08-14 06:18:47 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
|
|
|
|
lower_bound(const _K2& __k) {return __tree_.lower_bound(__k);}
|
|
|
|
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
|
|
|
|
lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
|
|
|
|
#endif
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator upper_bound(const key_type& __k)
|
|
|
|
{return __tree_.upper_bound(__k);}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
const_iterator upper_bound(const key_type& __k) const
|
|
|
|
{return __tree_.upper_bound(__k);}
|
2013-08-14 06:18:47 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
|
|
|
|
upper_bound(const _K2& __k) {return __tree_.upper_bound(__k);}
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
|
|
|
|
upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
|
|
|
|
#endif
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
pair<iterator,iterator> equal_range(const key_type& __k)
|
|
|
|
{return __tree_.__equal_range_unique(__k);}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
|
|
|
|
{return __tree_.__equal_range_unique(__k);}
|
2013-08-14 06:18:47 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type
|
Use multi-key tree search for {map, set}::{count, equal_range}
Patch from ngolovliov@gmail.com
Reviewed as: https://reviews.llvm.org/D42344
As described in llvm.org/PR30959, the current
implementation of std::{map, key}::{count, equal_range} in libcxx is
non-conforming. Quoting the C++14 standard [associative.reqmts]p3
> The phrase “equivalence of keys” means the equivalence relation imposed by
> the comparison and not the operator== on keys. That is, two keys k1 and k2 are
> considered to be equivalent if for the comparison object comp,
> comp(k1, k2) == false && comp(k2, k1) == false.
In the same section, the requirements table states the following:
> a.equal_range(k) equivalent to make_pair(a.lower_bound(k), a.upper_bound(k))
> a.count(k) returns the number of elements with key equivalent to k
The behaviour of libstdc++ seems to conform to the standard here.
llvm-svn: 324799
2018-02-10 10:53:47 +08:00
|
|
|
equal_range(const _K2& __k) {return __tree_.__equal_range_multi(__k);}
|
2013-08-14 06:18:47 +08:00
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type
|
Use multi-key tree search for {map, set}::{count, equal_range}
Patch from ngolovliov@gmail.com
Reviewed as: https://reviews.llvm.org/D42344
As described in llvm.org/PR30959, the current
implementation of std::{map, key}::{count, equal_range} in libcxx is
non-conforming. Quoting the C++14 standard [associative.reqmts]p3
> The phrase “equivalence of keys” means the equivalence relation imposed by
> the comparison and not the operator== on keys. That is, two keys k1 and k2 are
> considered to be equivalent if for the comparison object comp,
> comp(k1, k2) == false && comp(k2, k1) == false.
In the same section, the requirements table states the following:
> a.equal_range(k) equivalent to make_pair(a.lower_bound(k), a.upper_bound(k))
> a.count(k) returns the number of elements with key equivalent to k
The behaviour of libstdc++ seems to conform to the standard here.
llvm-svn: 324799
2018-02-10 10:53:47 +08:00
|
|
|
equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
|
2013-08-14 06:18:47 +08:00
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
private:
|
|
|
|
typedef typename __base::__node __node;
|
|
|
|
typedef typename __base::__node_allocator __node_allocator;
|
|
|
|
typedef typename __base::__node_pointer __node_pointer;
|
|
|
|
typedef typename __base::__node_base_pointer __node_base_pointer;
|
2017-01-05 14:06:18 +08:00
|
|
|
typedef typename __base::__parent_pointer __parent_pointer;
|
2016-02-20 15:12:17 +08:00
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
typedef __map_node_destructor<__node_allocator> _Dp;
|
|
|
|
typedef unique_ptr<__node, _Dp> __node_holder;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2016-03-31 11:13:37 +08:00
|
|
|
#ifdef _LIBCPP_CXX03_LANG
|
2013-07-05 04:59:16 +08:00
|
|
|
__node_holder __construct_node_with_key(const key_type& __k);
|
2016-03-31 11:13:37 +08:00
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
2019-06-21 03:32:00 +08:00
|
|
|
#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
|
|
|
|
template<class _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>,
|
|
|
|
class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
|
2019-07-20 01:13:39 +08:00
|
|
|
class = _EnableIf<!__is_allocator<_Compare>::value, void>,
|
|
|
|
class = _EnableIf<__is_allocator<_Allocator>::value, void>>
|
2019-06-21 03:32:00 +08:00
|
|
|
map(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())
|
|
|
|
-> map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare, _Allocator>;
|
|
|
|
|
|
|
|
template<class _Key, class _Tp, class _Compare = less<remove_const_t<_Key>>,
|
|
|
|
class _Allocator = allocator<pair<const _Key, _Tp>>,
|
2019-07-20 01:13:39 +08:00
|
|
|
class = _EnableIf<!__is_allocator<_Compare>::value, void>,
|
|
|
|
class = _EnableIf<__is_allocator<_Allocator>::value, void>>
|
2019-06-21 03:32:00 +08:00
|
|
|
map(initializer_list<pair<_Key, _Tp>>, _Compare = _Compare(), _Allocator = _Allocator())
|
|
|
|
-> map<remove_const_t<_Key>, _Tp, _Compare, _Allocator>;
|
|
|
|
|
|
|
|
template<class _InputIterator, class _Allocator,
|
2019-07-20 01:13:39 +08:00
|
|
|
class = _EnableIf<__is_allocator<_Allocator>::value, void>>
|
2019-06-21 03:32:00 +08:00
|
|
|
map(_InputIterator, _InputIterator, _Allocator)
|
|
|
|
-> map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
|
|
|
|
less<__iter_key_type<_InputIterator>>, _Allocator>;
|
|
|
|
|
|
|
|
template<class _Key, class _Tp, class _Allocator,
|
2019-07-20 01:13:39 +08:00
|
|
|
class = _EnableIf<__is_allocator<_Allocator>::value, void>>
|
2019-06-21 03:32:00 +08:00
|
|
|
map(initializer_list<pair<_Key, _Tp>>, _Allocator)
|
|
|
|
-> map<remove_const_t<_Key>, _Tp, less<remove_const_t<_Key>>, _Allocator>;
|
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2016-03-31 10:15:15 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
|
|
|
map<_Key, _Tp, _Compare, _Allocator>::map(map&& __m, const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __tree_(_VSTD::move(__m.__tree_), typename __base::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
if (__a != __m.get_allocator())
|
|
|
|
{
|
|
|
|
const_iterator __e = cend();
|
|
|
|
while (!__m.empty())
|
|
|
|
__tree_.__insert_unique(__e.__i_,
|
2018-06-05 04:38:23 +08:00
|
|
|
__m.__tree_.remove(__m.begin().__i_)->__value_.__move());
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-19 05:08:06 +08:00
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
|
|
|
_Tp&
|
|
|
|
map<_Key, _Tp, _Compare, _Allocator>::operator[](const key_type& __k)
|
|
|
|
{
|
|
|
|
return __tree_.__emplace_unique_key_args(__k,
|
|
|
|
_VSTD::piecewise_construct,
|
|
|
|
_VSTD::forward_as_tuple(__k),
|
2018-06-05 04:38:23 +08:00
|
|
|
_VSTD::forward_as_tuple()).first->__get_value().second;
|
2017-04-19 05:08:06 +08:00
|
|
|
}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2017-04-19 05:08:06 +08:00
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
|
|
|
_Tp&
|
|
|
|
map<_Key, _Tp, _Compare, _Allocator>::operator[](key_type&& __k)
|
|
|
|
{
|
|
|
|
return __tree_.__emplace_unique_key_args(__k,
|
|
|
|
_VSTD::piecewise_construct,
|
|
|
|
_VSTD::forward_as_tuple(_VSTD::move(__k)),
|
2018-06-05 04:38:23 +08:00
|
|
|
_VSTD::forward_as_tuple()).first->__get_value().second;
|
2017-04-19 05:08:06 +08:00
|
|
|
}
|
2012-05-26 06:04:21 +08:00
|
|
|
|
2017-04-19 05:08:06 +08:00
|
|
|
#else // _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
|
|
|
typename map<_Key, _Tp, _Compare, _Allocator>::__node_holder
|
2013-07-05 04:59:16 +08:00
|
|
|
map<_Key, _Tp, _Compare, _Allocator>::__construct_node_with_key(const key_type& __k)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
__node_allocator& __na = __tree_.__node_alloc();
|
2011-11-30 02:15:50 +08:00
|
|
|
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
2018-06-05 04:38:23 +08:00
|
|
|
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.__get_value().first), __k);
|
2010-05-12 03:42:16 +08:00
|
|
|
__h.get_deleter().__first_constructed = true;
|
2018-06-05 04:38:23 +08:00
|
|
|
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.__get_value().second));
|
2010-05-12 03:42:16 +08:00
|
|
|
__h.get_deleter().__second_constructed = true;
|
2020-07-30 21:42:23 +08:00
|
|
|
return __h;
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
|
|
|
_Tp&
|
|
|
|
map<_Key, _Tp, _Compare, _Allocator>::operator[](const key_type& __k)
|
|
|
|
{
|
2017-01-05 14:06:18 +08:00
|
|
|
__parent_pointer __parent;
|
|
|
|
__node_base_pointer& __child = __tree_.__find_equal(__parent, __k);
|
2010-05-12 03:42:16 +08:00
|
|
|
__node_pointer __r = static_cast<__node_pointer>(__child);
|
|
|
|
if (__child == nullptr)
|
|
|
|
{
|
2013-07-05 04:59:16 +08:00
|
|
|
__node_holder __h = __construct_node_with_key(__k);
|
2013-06-20 05:29:40 +08:00
|
|
|
__tree_.__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
|
2010-05-12 03:42:16 +08:00
|
|
|
__r = __h.release();
|
|
|
|
}
|
2018-06-05 04:38:23 +08:00
|
|
|
return __r->__value_.__get_value().second;
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
2017-04-19 05:08:06 +08:00
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
|
|
|
_Tp&
|
|
|
|
map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k)
|
|
|
|
{
|
2017-01-05 14:06:18 +08:00
|
|
|
__parent_pointer __parent;
|
|
|
|
__node_base_pointer& __child = __tree_.__find_equal(__parent, __k);
|
2010-05-12 03:42:16 +08:00
|
|
|
if (__child == nullptr)
|
2019-02-13 00:06:02 +08:00
|
|
|
__throw_out_of_range("map::at: key not found");
|
2018-06-05 04:38:23 +08:00
|
|
|
return static_cast<__node_pointer>(__child)->__value_.__get_value().second;
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
|
|
|
const _Tp&
|
|
|
|
map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k) const
|
|
|
|
{
|
2017-01-05 14:06:18 +08:00
|
|
|
__parent_pointer __parent;
|
|
|
|
__node_base_pointer __child = __tree_.__find_equal(__parent, __k);
|
2010-05-12 03:42:16 +08:00
|
|
|
if (__child == nullptr)
|
2019-02-13 00:06:02 +08:00
|
|
|
__throw_out_of_range("map::at: key not found");
|
2018-06-05 04:38:23 +08:00
|
|
|
return static_cast<__node_pointer>(__child)->__value_.__get_value().second;
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
2010-09-23 00:48:34 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool
|
|
|
|
operator==(const map<_Key, _Tp, _Compare, _Allocator>& __x,
|
|
|
|
const map<_Key, _Tp, _Compare, _Allocator>& __y)
|
|
|
|
{
|
2011-07-01 05:18:19 +08:00
|
|
|
return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
2010-09-23 00:48:34 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool
|
|
|
|
operator< (const map<_Key, _Tp, _Compare, _Allocator>& __x,
|
|
|
|
const map<_Key, _Tp, _Compare, _Allocator>& __y)
|
|
|
|
{
|
2011-07-01 05:18:19 +08:00
|
|
|
return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
2010-09-23 00:48:34 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool
|
|
|
|
operator!=(const map<_Key, _Tp, _Compare, _Allocator>& __x,
|
|
|
|
const map<_Key, _Tp, _Compare, _Allocator>& __y)
|
|
|
|
{
|
|
|
|
return !(__x == __y);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
2010-09-23 00:48:34 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool
|
|
|
|
operator> (const map<_Key, _Tp, _Compare, _Allocator>& __x,
|
|
|
|
const map<_Key, _Tp, _Compare, _Allocator>& __y)
|
|
|
|
{
|
|
|
|
return __y < __x;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
2010-09-23 00:48:34 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool
|
|
|
|
operator>=(const map<_Key, _Tp, _Compare, _Allocator>& __x,
|
|
|
|
const map<_Key, _Tp, _Compare, _Allocator>& __y)
|
|
|
|
{
|
|
|
|
return !(__x < __y);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
2010-09-23 00:48:34 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool
|
|
|
|
operator<=(const map<_Key, _Tp, _Compare, _Allocator>& __x,
|
|
|
|
const map<_Key, _Tp, _Compare, _Allocator>& __y)
|
|
|
|
{
|
|
|
|
return !(__y < __x);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
2010-09-23 00:48:34 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
void
|
|
|
|
swap(map<_Key, _Tp, _Compare, _Allocator>& __x,
|
|
|
|
map<_Key, _Tp, _Compare, _Allocator>& __y)
|
2011-06-04 22:31:57 +08:00
|
|
|
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
__x.swap(__y);
|
|
|
|
}
|
|
|
|
|
2018-12-15 02:49:35 +08:00
|
|
|
#if _LIBCPP_STD_VER > 17
|
2020-05-02 19:58:03 +08:00
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator,
|
|
|
|
class _Predicate>
|
2018-12-15 02:49:35 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2020-05-02 19:58:03 +08:00
|
|
|
typename map<_Key, _Tp, _Compare, _Allocator>::size_type
|
|
|
|
erase_if(map<_Key, _Tp, _Compare, _Allocator>& __c, _Predicate __pred) {
|
|
|
|
return __libcpp_erase_if_container(__c, __pred);
|
|
|
|
}
|
2018-12-15 02:49:35 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Key, class _Tp, class _Compare = less<_Key>,
|
|
|
|
class _Allocator = allocator<pair<const _Key, _Tp> > >
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS multimap
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
// types:
|
|
|
|
typedef _Key key_type;
|
|
|
|
typedef _Tp mapped_type;
|
|
|
|
typedef pair<const key_type, mapped_type> value_type;
|
2019-06-21 03:32:00 +08:00
|
|
|
typedef typename __identity<_Compare>::type key_compare;
|
|
|
|
typedef typename __identity<_Allocator>::type allocator_type;
|
2010-05-12 03:42:16 +08:00
|
|
|
typedef value_type& reference;
|
|
|
|
typedef const value_type& const_reference;
|
|
|
|
|
2015-11-26 09:24:04 +08:00
|
|
|
static_assert((is_same<typename allocator_type::value_type, value_type>::value),
|
|
|
|
"Allocator::value_type must be same type as value_type");
|
|
|
|
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS value_compare
|
2010-05-12 03:42:16 +08:00
|
|
|
: public binary_function<value_type, value_type, bool>
|
|
|
|
{
|
|
|
|
friend class multimap;
|
|
|
|
protected:
|
|
|
|
key_compare comp;
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
value_compare(key_compare c) : comp(c) {}
|
|
|
|
public:
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool operator()(const value_type& __x, const value_type& __y) const
|
|
|
|
{return comp(__x.first, __y.first);}
|
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
2013-06-20 05:29:40 +08:00
|
|
|
|
2013-10-01 03:08:22 +08:00
|
|
|
typedef _VSTD::__value_type<key_type, mapped_type> __value_type;
|
2013-07-06 02:06:00 +08:00
|
|
|
typedef __map_value_compare<key_type, __value_type, key_compare> __vc;
|
2015-04-07 13:21:38 +08:00
|
|
|
typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>,
|
|
|
|
__value_type>::type __allocator_type;
|
2010-05-12 03:42:16 +08:00
|
|
|
typedef __tree<__value_type, __vc, __allocator_type> __base;
|
|
|
|
typedef typename __base::__node_traits __node_traits;
|
|
|
|
typedef allocator_traits<allocator_type> __alloc_traits;
|
|
|
|
|
|
|
|
__base __tree_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
typedef typename __alloc_traits::pointer pointer;
|
|
|
|
typedef typename __alloc_traits::const_pointer const_pointer;
|
|
|
|
typedef typename __alloc_traits::size_type size_type;
|
|
|
|
typedef typename __alloc_traits::difference_type difference_type;
|
|
|
|
typedef __map_iterator<typename __base::iterator> iterator;
|
|
|
|
typedef __map_const_iterator<typename __base::const_iterator> const_iterator;
|
2011-07-01 05:18:19 +08:00
|
|
|
typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
|
|
|
|
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2018-08-01 09:33:38 +08:00
|
|
|
#if _LIBCPP_STD_VER > 14
|
|
|
|
typedef __map_node_handle<typename __base::__node, allocator_type> node_type;
|
|
|
|
#endif
|
|
|
|
|
2018-11-01 01:31:35 +08:00
|
|
|
template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
|
|
|
|
friend class _LIBCPP_TEMPLATE_VIS map;
|
|
|
|
template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
|
|
|
|
friend class _LIBCPP_TEMPLATE_VIS multimap;
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2014-03-10 12:50:10 +08:00
|
|
|
multimap()
|
|
|
|
_NOEXCEPT_(
|
|
|
|
is_nothrow_default_constructible<allocator_type>::value &&
|
|
|
|
is_nothrow_default_constructible<key_compare>::value &&
|
|
|
|
is_nothrow_copy_constructible<key_compare>::value)
|
|
|
|
: __tree_(__vc(key_compare())) {}
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
explicit multimap(const key_compare& __comp)
|
2011-06-04 22:31:57 +08:00
|
|
|
_NOEXCEPT_(
|
|
|
|
is_nothrow_default_constructible<allocator_type>::value &&
|
|
|
|
is_nothrow_copy_constructible<key_compare>::value)
|
2010-05-12 03:42:16 +08:00
|
|
|
: __tree_(__vc(__comp)) {}
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
explicit multimap(const key_compare& __comp, const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __tree_(__vc(__comp), typename __base::allocator_type(__a)) {}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
template <class _InputIterator>
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
multimap(_InputIterator __f, _InputIterator __l,
|
|
|
|
const key_compare& __comp = key_compare())
|
|
|
|
: __tree_(__vc(__comp))
|
|
|
|
{
|
|
|
|
insert(__f, __l);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _InputIterator>
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
multimap(_InputIterator __f, _InputIterator __l,
|
|
|
|
const key_compare& __comp, const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __tree_(__vc(__comp), typename __base::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
insert(__f, __l);
|
|
|
|
}
|
|
|
|
|
2013-09-11 09:15:47 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _InputIterator>
|
2017-01-05 14:06:18 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2013-09-11 09:15:47 +08:00
|
|
|
multimap(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
|
|
|
|
: multimap(__f, __l, key_compare(), __a) {}
|
|
|
|
#endif
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
multimap(const multimap& __m)
|
|
|
|
: __tree_(__m.__tree_.value_comp(),
|
|
|
|
__alloc_traits::select_on_container_copy_construction(__m.__tree_.__alloc()))
|
|
|
|
{
|
|
|
|
insert(__m.begin(), __m.end());
|
|
|
|
}
|
|
|
|
|
2011-07-02 03:24:36 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
multimap& operator=(const multimap& __m)
|
|
|
|
{
|
2016-07-18 21:19:00 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2011-07-02 03:24:36 +08:00
|
|
|
__tree_ = __m.__tree_;
|
2013-06-20 05:29:40 +08:00
|
|
|
#else
|
2014-02-08 12:03:14 +08:00
|
|
|
if (this != &__m) {
|
|
|
|
__tree_.clear();
|
|
|
|
__tree_.value_comp() = __m.__tree_.value_comp();
|
|
|
|
__tree_.__copy_assign_alloc(__m.__tree_);
|
|
|
|
insert(__m.begin(), __m.end());
|
|
|
|
}
|
2013-06-20 05:29:40 +08:00
|
|
|
#endif
|
2011-07-02 03:24:36 +08:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2017-04-19 05:08:06 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
multimap(multimap&& __m)
|
2011-06-04 22:31:57 +08:00
|
|
|
_NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
|
2011-07-01 05:18:19 +08:00
|
|
|
: __tree_(_VSTD::move(__m.__tree_))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
multimap(multimap&& __m, const allocator_type& __a);
|
|
|
|
|
2011-08-13 05:56:02 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
multimap& operator=(multimap&& __m)
|
|
|
|
_NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
|
|
|
|
{
|
|
|
|
__tree_ = _VSTD::move(__m.__tree_);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
multimap(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
|
|
|
|
: __tree_(__vc(__comp))
|
|
|
|
{
|
|
|
|
insert(__il.begin(), __il.end());
|
|
|
|
}
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
multimap(initializer_list<value_type> __il, const key_compare& __comp, const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __tree_(__vc(__comp), typename __base::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
insert(__il.begin(), __il.end());
|
|
|
|
}
|
|
|
|
|
2013-09-11 09:15:47 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
2017-01-05 14:06:18 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2013-09-11 09:15:47 +08:00
|
|
|
multimap(initializer_list<value_type> __il, const allocator_type& __a)
|
|
|
|
: multimap(__il, key_compare(), __a) {}
|
|
|
|
#endif
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
multimap& operator=(initializer_list<value_type> __il)
|
|
|
|
{
|
|
|
|
__tree_.__assign_multi(__il.begin(), __il.end());
|
|
|
|
return *this;
|
|
|
|
}
|
2011-08-13 05:56:02 +08:00
|
|
|
|
2017-04-19 05:08:06 +08:00
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
explicit multimap(const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __tree_(typename __base::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
multimap(const multimap& __m, const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __tree_(__m.__tree_.value_comp(), typename __base::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
insert(__m.begin(), __m.end());
|
|
|
|
}
|
|
|
|
|
[libc++] Make sure we don't eagerly diagnose non-const comparators for containers of incomplete types
Summary:
In r348529, I improved the library-defined diagnostic for using containers
with a non-const comparator/hasher. However, the check is now performed
too early, which leads to the diagnostic being emitted in cases where it
shouldn't. See PR41360 for details.
This patch moves the diagnostic to the destructor of the containers, which
means that the diagnostic will only be emitted when the container is instantiated
at a point where the comparator and the key/value are required to be complete.
We still retain better diagnostics than before r348529, because the diagnostics
are performed in the containers themselves instead of __tree and __hash_table.
As a drive-by fix, I improved the diagnostic to mention that we can't find
a _viable_ const call operator, as suggested by EricWF in PR41360.
Reviewers: EricWF, mclow.lists
Subscribers: christof, jkorous, dexonsmith, libcxx-commits, zoecarver
Tags: #libc
Differential Revision: https://reviews.llvm.org/D60540
llvm-svn: 358189
2019-04-12 00:14:56 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
~multimap() {
|
|
|
|
static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), "");
|
|
|
|
}
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
iterator begin() _NOEXCEPT {return __tree_.begin();}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
const_iterator begin() const _NOEXCEPT {return __tree_.begin();}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
iterator end() _NOEXCEPT {return __tree_.end();}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
const_iterator end() const _NOEXCEPT {return __tree_.end();}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
const_reverse_iterator rbegin() const _NOEXCEPT
|
|
|
|
{return const_reverse_iterator(end());}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
const_reverse_iterator rend() const _NOEXCEPT
|
|
|
|
{return const_reverse_iterator(begin());}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
const_iterator cbegin() const _NOEXCEPT {return begin();}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
const_iterator cend() const _NOEXCEPT {return end();}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
const_reverse_iterator crend() const _NOEXCEPT {return rend();}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2017-11-15 13:51:26 +08:00
|
|
|
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
bool empty() const _NOEXCEPT {return __tree_.size() == 0;}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
size_type size() const _NOEXCEPT {return __tree_.size();}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
size_type max_size() const _NOEXCEPT {return __tree_.max_size();}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2016-08-17 13:58:40 +08:00
|
|
|
allocator_type get_allocator() const _NOEXCEPT {return allocator_type(__tree_.__alloc());}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
key_compare key_comp() const {return __tree_.value_comp().key_comp();}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
value_compare value_comp() const
|
|
|
|
{return value_compare(__tree_.value_comp().key_comp());}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2016-03-31 10:15:15 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2010-09-05 07:28:19 +08:00
|
|
|
|
2012-05-26 06:04:21 +08:00
|
|
|
template <class ..._Args>
|
2016-03-31 10:15:15 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator emplace(_Args&& ...__args) {
|
|
|
|
return __tree_.__emplace_multi(_VSTD::forward<_Args>(__args)...);
|
|
|
|
}
|
2010-09-05 07:28:19 +08:00
|
|
|
|
2012-05-26 06:04:21 +08:00
|
|
|
template <class ..._Args>
|
2016-03-31 10:15:15 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator emplace_hint(const_iterator __p, _Args&& ...__args) {
|
|
|
|
return __tree_.__emplace_hint_multi(__p.__i_, _VSTD::forward<_Args>(__args)...);
|
|
|
|
}
|
2010-09-05 07:28:19 +08:00
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template <class _Pp,
|
|
|
|
class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-11-30 02:15:50 +08:00
|
|
|
iterator insert(_Pp&& __p)
|
|
|
|
{return __tree_.__insert_multi(_VSTD::forward<_Pp>(__p));}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template <class _Pp,
|
|
|
|
class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-11-30 02:15:50 +08:00
|
|
|
iterator insert(const_iterator __pos, _Pp&& __p)
|
|
|
|
{return __tree_.__insert_multi(__pos.__i_, _VSTD::forward<_Pp>(__p));}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2016-04-18 09:40:45 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator insert(value_type&& __v)
|
|
|
|
{return __tree_.__insert_multi(_VSTD::move(__v));}
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator insert(const_iterator __p, value_type&& __v)
|
|
|
|
{return __tree_.__insert_multi(__p.__i_, _VSTD::move(__v));}
|
|
|
|
|
2017-04-19 05:08:06 +08:00
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
void insert(initializer_list<value_type> __il)
|
|
|
|
{insert(__il.begin(), __il.end());}
|
|
|
|
|
2016-03-31 10:15:15 +08:00
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator insert(const value_type& __v) {return __tree_.__insert_multi(__v);}
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator insert(const_iterator __p, const value_type& __v)
|
|
|
|
{return __tree_.__insert_multi(__p.__i_, __v);}
|
|
|
|
|
|
|
|
template <class _InputIterator>
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
void insert(_InputIterator __f, _InputIterator __l)
|
|
|
|
{
|
|
|
|
for (const_iterator __e = cend(); __f != __l; ++__f)
|
|
|
|
__tree_.__insert_multi(__e.__i_, *__f);
|
|
|
|
}
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator erase(const_iterator __p) {return __tree_.erase(__p.__i_);}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2015-05-10 21:35:00 +08:00
|
|
|
iterator erase(iterator __p) {return __tree_.erase(__p.__i_);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
size_type erase(const key_type& __k) {return __tree_.__erase_multi(__k);}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator erase(const_iterator __f, const_iterator __l)
|
|
|
|
{return __tree_.erase(__f.__i_, __l.__i_);}
|
2018-08-01 09:33:38 +08:00
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 14
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator insert(node_type&& __nh)
|
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
|
|
|
|
"node_type with incompatible allocator passed to multimap::insert()");
|
|
|
|
return __tree_.template __node_handle_insert_multi<node_type>(
|
|
|
|
_VSTD::move(__nh));
|
|
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
iterator insert(const_iterator __hint, node_type&& __nh)
|
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
|
|
|
|
"node_type with incompatible allocator passed to multimap::insert()");
|
|
|
|
return __tree_.template __node_handle_insert_multi<node_type>(
|
|
|
|
__hint.__i_, _VSTD::move(__nh));
|
|
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
node_type extract(key_type const& __key)
|
|
|
|
{
|
|
|
|
return __tree_.template __node_handle_extract<node_type>(__key);
|
|
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
node_type extract(const_iterator __it)
|
|
|
|
{
|
|
|
|
return __tree_.template __node_handle_extract<node_type>(
|
|
|
|
__it.__i_);
|
|
|
|
}
|
2018-11-01 22:41:37 +08:00
|
|
|
template <class _Compare2>
|
2018-11-01 01:31:35 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-11-01 22:41:37 +08:00
|
|
|
void merge(multimap<key_type, mapped_type, _Compare2, allocator_type>& __source)
|
2018-11-01 01:31:35 +08:00
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
|
|
|
|
"merging container with incompatible allocator");
|
|
|
|
return __tree_.__node_handle_merge_multi(__source.__tree_);
|
|
|
|
}
|
2018-11-01 22:41:37 +08:00
|
|
|
template <class _Compare2>
|
2018-11-01 01:31:35 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-11-01 22:41:37 +08:00
|
|
|
void merge(multimap<key_type, mapped_type, _Compare2, allocator_type>&& __source)
|
2018-11-01 01:31:35 +08:00
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
|
|
|
|
"merging container with incompatible allocator");
|
|
|
|
return __tree_.__node_handle_merge_multi(__source.__tree_);
|
|
|
|
}
|
2018-11-01 22:41:37 +08:00
|
|
|
template <class _Compare2>
|
2018-11-01 01:31:35 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-11-01 22:41:37 +08:00
|
|
|
void merge(map<key_type, mapped_type, _Compare2, allocator_type>& __source)
|
2018-11-01 01:31:35 +08:00
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
|
|
|
|
"merging container with incompatible allocator");
|
|
|
|
return __tree_.__node_handle_merge_multi(__source.__tree_);
|
|
|
|
}
|
2018-11-01 22:41:37 +08:00
|
|
|
template <class _Compare2>
|
2018-11-01 01:31:35 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-11-01 22:41:37 +08:00
|
|
|
void merge(map<key_type, mapped_type, _Compare2, allocator_type>&& __source)
|
2018-11-01 01:31:35 +08:00
|
|
|
{
|
|
|
|
_LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
|
|
|
|
"merging container with incompatible allocator");
|
|
|
|
return __tree_.__node_handle_merge_multi(__source.__tree_);
|
|
|
|
}
|
2018-08-01 09:33:38 +08:00
|
|
|
#endif
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2018-08-22 12:28:43 +08:00
|
|
|
void clear() _NOEXCEPT {__tree_.clear();}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-06-04 22:31:57 +08:00
|
|
|
void swap(multimap& __m)
|
|
|
|
_NOEXCEPT_(__is_nothrow_swappable<__base>::value)
|
|
|
|
{__tree_.swap(__m.__tree_);}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator find(const key_type& __k) {return __tree_.find(__k);}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
|
2013-08-14 06:18:47 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
|
|
|
|
find(const _K2& __k) {return __tree_.find(__k);}
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
|
|
|
|
find(const _K2& __k) const {return __tree_.find(__k);}
|
|
|
|
#endif
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
size_type count(const key_type& __k) const
|
|
|
|
{return __tree_.__count_multi(__k);}
|
2014-08-25 07:54:16 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type
|
2015-07-01 02:15:41 +08:00
|
|
|
count(const _K2& __k) const {return __tree_.__count_multi(__k);}
|
2014-08-25 07:54:16 +08:00
|
|
|
#endif
|
2019-07-16 11:21:01 +08:00
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 17
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool contains(const key_type& __k) const {return find(__k) != end();}
|
|
|
|
#endif // _LIBCPP_STD_VER > 17
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator lower_bound(const key_type& __k)
|
|
|
|
{return __tree_.lower_bound(__k);}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
const_iterator lower_bound(const key_type& __k) const
|
|
|
|
{return __tree_.lower_bound(__k);}
|
2013-08-14 06:18:47 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
|
|
|
|
lower_bound(const _K2& __k) {return __tree_.lower_bound(__k);}
|
|
|
|
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
|
|
|
|
lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
|
|
|
|
#endif
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
iterator upper_bound(const key_type& __k)
|
|
|
|
{return __tree_.upper_bound(__k);}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
const_iterator upper_bound(const key_type& __k) const
|
|
|
|
{return __tree_.upper_bound(__k);}
|
2013-08-14 06:18:47 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
|
|
|
|
upper_bound(const _K2& __k) {return __tree_.upper_bound(__k);}
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
|
|
|
|
upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
|
|
|
|
#endif
|
|
|
|
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
pair<iterator,iterator> equal_range(const key_type& __k)
|
|
|
|
{return __tree_.__equal_range_multi(__k);}
|
2010-09-23 00:48:34 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
|
|
|
|
{return __tree_.__equal_range_multi(__k);}
|
2013-08-14 06:18:47 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type
|
|
|
|
equal_range(const _K2& __k) {return __tree_.__equal_range_multi(__k);}
|
|
|
|
template <typename _K2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename enable_if<__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type
|
|
|
|
equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
|
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
private:
|
|
|
|
typedef typename __base::__node __node;
|
|
|
|
typedef typename __base::__node_allocator __node_allocator;
|
|
|
|
typedef typename __base::__node_pointer __node_pointer;
|
2016-02-20 15:12:17 +08:00
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
typedef __map_node_destructor<__node_allocator> _Dp;
|
|
|
|
typedef unique_ptr<__node, _Dp> __node_holder;
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
2019-06-21 03:32:00 +08:00
|
|
|
#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
|
|
|
|
template<class _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>,
|
|
|
|
class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
|
2019-07-20 01:13:39 +08:00
|
|
|
class = _EnableIf<!__is_allocator<_Compare>::value, void>,
|
|
|
|
class = _EnableIf<__is_allocator<_Allocator>::value, void>>
|
2019-06-21 03:32:00 +08:00
|
|
|
multimap(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())
|
|
|
|
-> multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare, _Allocator>;
|
|
|
|
|
|
|
|
template<class _Key, class _Tp, class _Compare = less<remove_const_t<_Key>>,
|
|
|
|
class _Allocator = allocator<pair<const _Key, _Tp>>,
|
2019-07-20 01:13:39 +08:00
|
|
|
class = _EnableIf<!__is_allocator<_Compare>::value, void>,
|
|
|
|
class = _EnableIf<__is_allocator<_Allocator>::value, void>>
|
2019-06-21 03:32:00 +08:00
|
|
|
multimap(initializer_list<pair<_Key, _Tp>>, _Compare = _Compare(), _Allocator = _Allocator())
|
|
|
|
-> multimap<remove_const_t<_Key>, _Tp, _Compare, _Allocator>;
|
|
|
|
|
|
|
|
template<class _InputIterator, class _Allocator,
|
2019-07-20 01:13:39 +08:00
|
|
|
class = _EnableIf<__is_allocator<_Allocator>::value, void>>
|
2019-06-21 03:32:00 +08:00
|
|
|
multimap(_InputIterator, _InputIterator, _Allocator)
|
|
|
|
-> multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
|
|
|
|
less<__iter_key_type<_InputIterator>>, _Allocator>;
|
|
|
|
|
|
|
|
template<class _Key, class _Tp, class _Allocator,
|
2019-07-20 01:13:39 +08:00
|
|
|
class = _EnableIf<__is_allocator<_Allocator>::value, void>>
|
2019-06-21 03:32:00 +08:00
|
|
|
multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
|
|
|
|
-> multimap<remove_const_t<_Key>, _Tp, less<remove_const_t<_Key>>, _Allocator>;
|
|
|
|
#endif
|
|
|
|
|
2016-03-31 10:15:15 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
|
|
|
multimap<_Key, _Tp, _Compare, _Allocator>::multimap(multimap&& __m, const allocator_type& __a)
|
2016-08-17 13:58:40 +08:00
|
|
|
: __tree_(_VSTD::move(__m.__tree_), typename __base::allocator_type(__a))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
if (__a != __m.get_allocator())
|
|
|
|
{
|
|
|
|
const_iterator __e = cend();
|
|
|
|
while (!__m.empty())
|
|
|
|
__tree_.__insert_multi(__e.__i_,
|
2018-06-05 04:38:23 +08:00
|
|
|
_VSTD::move(__m.__tree_.remove(__m.begin().__i_)->__value_.__move()));
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
}
|
2016-03-31 10:15:15 +08:00
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
2010-09-23 00:48:34 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool
|
|
|
|
operator==(const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
|
|
|
|
const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
|
|
|
|
{
|
2011-07-01 05:18:19 +08:00
|
|
|
return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
2010-09-23 00:48:34 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool
|
|
|
|
operator< (const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
|
|
|
|
const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
|
|
|
|
{
|
2011-07-01 05:18:19 +08:00
|
|
|
return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
2010-09-23 00:48:34 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool
|
|
|
|
operator!=(const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
|
|
|
|
const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
|
|
|
|
{
|
|
|
|
return !(__x == __y);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
2010-09-23 00:48:34 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool
|
|
|
|
operator> (const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
|
|
|
|
const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
|
|
|
|
{
|
|
|
|
return __y < __x;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
2010-09-23 00:48:34 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool
|
|
|
|
operator>=(const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
|
|
|
|
const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
|
|
|
|
{
|
|
|
|
return !(__x < __y);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
2010-09-23 00:48:34 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool
|
|
|
|
operator<=(const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
|
|
|
|
const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
|
|
|
|
{
|
|
|
|
return !(__y < __x);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
2010-09-23 00:48:34 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
void
|
|
|
|
swap(multimap<_Key, _Tp, _Compare, _Allocator>& __x,
|
|
|
|
multimap<_Key, _Tp, _Compare, _Allocator>& __y)
|
2011-06-04 22:31:57 +08:00
|
|
|
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
__x.swap(__y);
|
|
|
|
}
|
|
|
|
|
2018-12-15 02:49:35 +08:00
|
|
|
#if _LIBCPP_STD_VER > 17
|
2020-05-02 19:58:03 +08:00
|
|
|
template <class _Key, class _Tp, class _Compare, class _Allocator,
|
|
|
|
class _Predicate>
|
2018-12-15 02:49:35 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2020-05-02 19:58:03 +08:00
|
|
|
typename multimap<_Key, _Tp, _Compare, _Allocator>::size_type
|
|
|
|
erase_if(multimap<_Key, _Tp, _Compare, _Allocator>& __c,
|
|
|
|
_Predicate __pred) {
|
|
|
|
return __libcpp_erase_if_container(__c, __pred);
|
|
|
|
}
|
2018-12-15 02:49:35 +08:00
|
|
|
#endif
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
|
|
|
|
#endif // _LIBCPP_MAP
|