16 KiB
[flat.map.defn]
23 Containers library [containers]
23.6 Container adaptors [container.adaptors]
23.6.8 Class template flat_map [flat.map]
23.6.8.2 Definition [flat.map.defn]
namespace std {template<class Key, class T, class Compare = less, class KeyContainer = vector, class MappedContainer = vector>class flat_map {public:// typesusing key_type = Key; using mapped_type = T; using value_type = pair<key_type, mapped_type>; using key_compare = Compare; using reference = pair<const key_type&, mapped_type&>; using const_reference = pair<const key_type&, const mapped_type&>; using size_type = size_t; using difference_type = ptrdiff_t; using iterator = implementation-defined; // see [container.requirements]using const_iterator = implementation-defined; // see [container.requirements]using reverse_iterator = std::reverse_iterator; using const_reverse_iterator = std::reverse_iterator<const_iterator>; using key_container_type = KeyContainer; using mapped_container_type = MappedContainer; class value_compare {private: key_compare comp; // exposition onlyconstexpr value_compare(key_compare c) : comp(c) { } // exposition onlypublic:constexpr bool operator()(const_reference x, const_reference y) const {return comp(x.first, y.first); }}; struct containers { key_container_type keys; mapped_container_type values; }; // [flat.map.cons], constructorsconstexpr flat_map() : flat_map(key_compare()) { }constexpr explicit flat_map(const key_compare& comp): c(), compare(comp) { }constexpr flat_map(key_container_type key_cont, mapped_container_type mapped_cont, const key_compare& comp = key_compare()); constexpr flat_map(sorted_unique_t, key_container_type key_cont, mapped_container_type mapped_cont, const key_compare& comp = key_compare()); templateconstexpr flat_map(InputIterator first, InputIterator last, const key_compare& comp = key_compare()): c(), compare(comp) { insert(first, last); }templateconstexpr flat_map(sorted_unique_t, InputIterator first, InputIterator last, const key_compare& comp = key_compare()): c(), compare(comp) { insert(sorted_unique, first, last); }template<container-compatible-range<value_type> R>constexpr flat_map(from_range_t, R&& rg): flat_map(from_range, std::forward(rg), key_compare()) { }template<container-compatible-range<value_type> R>constexpr flat_map(from_range_t, R&& rg, const key_compare& comp): flat_map(comp) { insert_range(std::forward(rg)); }constexpr flat_map(initializer_list<value_type> il, const key_compare& comp = key_compare()): flat_map(il.begin(), il.end(), comp) { }constexpr flat_map(sorted_unique_t, initializer_list<value_type> il, const key_compare& comp = key_compare()): flat_map(sorted_unique, il.begin(), il.end(), comp) { }// [flat.map.cons.alloc], constructors with allocatorstemplateconstexpr explicit flat_map(const Alloc& a); templateconstexpr flat_map(const key_compare& comp, const Alloc& a); templateconstexpr flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont, const Alloc& a); templateconstexpr flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont, const key_compare& comp, const Alloc& a); templateconstexpr flat_map(sorted_unique_t, const key_container_type& key_cont, const mapped_container_type& mapped_cont, const Alloc& a); templateconstexpr flat_map(sorted_unique_t, const key_container_type& key_cont, const mapped_container_type& mapped_cont, const key_compare& comp, const Alloc& a); templateconstexpr flat_map(const flat_map&, const Alloc& a); templateconstexpr flat_map(flat_map&&, const Alloc& a); template<class InputIterator, class Alloc>constexpr flat_map(InputIterator first, InputIterator last, const Alloc& a); template<class InputIterator, class Alloc>constexpr flat_map(InputIterator first, InputIterator last, const key_compare& comp, const Alloc& a); template<class InputIterator, class Alloc>constexpr flat_map(sorted_unique_t, InputIterator first, InputIterator last, const Alloc& a); template<class InputIterator, class Alloc>constexpr flat_map(sorted_unique_t, InputIterator first, InputIterator last, const key_compare& comp, const Alloc& a); template<container-compatible-range<value_type> R, class Alloc>constexpr flat_map(from_range_t, R&& rg, const Alloc& a); template<container-compatible-range<value_type> R, class Alloc>constexpr flat_map(from_range_t, R&& rg, const key_compare& comp, const Alloc& a); templateconstexpr flat_map(initializer_list<value_type> il, const Alloc& a); templateconstexpr flat_map(initializer_list<value_type> il, const key_compare& comp, const Alloc& a); templateconstexpr flat_map(sorted_unique_t, initializer_list<value_type> il, const Alloc& a); templateconstexpr flat_map(sorted_unique_t, initializer_list<value_type> il, const key_compare& comp, const Alloc& a); constexpr flat_map& operator=(initializer_list<value_type>); // iteratorsconstexpr iterator begin() noexcept; constexpr const_iterator begin() const noexcept; constexpr iterator end() noexcept; constexpr const_iterator end() const noexcept; constexpr reverse_iterator rbegin() noexcept; constexpr const_reverse_iterator rbegin() const noexcept; constexpr reverse_iterator rend() noexcept; constexpr const_reverse_iterator rend() const noexcept; constexpr const_iterator cbegin() const noexcept; constexpr const_iterator cend() const noexcept; constexpr const_reverse_iterator crbegin() const noexcept; constexpr const_reverse_iterator crend() const noexcept; // [flat.map.capacity], capacityconstexpr bool empty() const noexcept; constexpr size_type size() const noexcept; constexpr size_type max_size() const noexcept; // [flat.map.access], element accessconstexpr mapped_type& operator[](const key_type& x); constexpr mapped_type& operator[](key_type&& x); template constexpr mapped_type& operator[](K&& x); constexpr mapped_type& at(const key_type& x); constexpr const mapped_type& at(const key_type& x) const; template constexpr mapped_type& at(const K& x); template constexpr const mapped_type& at(const K& x) const; // [flat.map.modifiers], modifierstemplate<class... Args> constexpr pair<iterator, bool> emplace(Args&&... args); template<class... Args>constexpr iterator emplace_hint(const_iterator position, Args&&... args); constexpr pair<iterator, bool> insert(const value_type& x){ return emplace(x); }constexpr pair<iterator, bool> insert(value_type&& x){ return emplace(std::move(x)); }constexpr iterator insert(const_iterator position, const value_type& x){ return emplace_hint(position, x); }constexpr iterator insert(const_iterator position, value_type&& x){ return emplace_hint(position, std::move(x)); }template constexpr pair<iterator, bool> insert(P&& x); templateconstexpr iterator insert(const_iterator position, P&&); templateconstexpr void insert(InputIterator first, InputIterator last); templateconstexpr void insert(sorted_unique_t, InputIterator first, InputIterator last); template<container-compatible-range<value_type> R>constexpr void insert_range(R&& rg); constexpr void insert(initializer_list<value_type> il){ insert(il.begin(), il.end()); }constexpr void insert(sorted_unique_t, initializer_list<value_type> il){ insert(sorted_unique, il.begin(), il.end()); }constexpr containers extract() &&; constexpr void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont); template<class... Args>constexpr pair<iterator, bool> try_emplace(const key_type& k, Args&&... args); template<class... Args>constexpr pair<iterator, bool> try_emplace(key_type&& k, Args&&... args); template<class K, class... Args>constexpr pair<iterator, bool> try_emplace(K&& k, Args&&... args); template<class... Args>constexpr iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); template<class... Args>constexpr iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); template<class K, class... Args>constexpr iterator try_emplace(const_iterator hint, K&& k, Args&&... args); templateconstexpr pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj); templateconstexpr pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj); template<class K, class M>constexpr pair<iterator, bool> insert_or_assign(K&& k, M&& obj); templateconstexpr iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); templateconstexpr iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); template<class K, class M>constexpr iterator insert_or_assign(const_iterator hint, K&& k, M&& obj); constexpr iterator erase(iterator position); constexpr iterator erase(const_iterator position); constexpr size_type erase(const key_type& x); template constexpr size_type erase(K&& x); constexpr iterator erase(const_iterator first, const_iterator last); constexpr void swap(flat_map& y) noexcept; constexpr void clear() noexcept; // observersconstexpr key_compare key_comp() const; constexpr value_compare value_comp() const; constexpr const key_container_type& keys() const noexcept { return c.keys; }constexpr const mapped_container_type& values() const noexcept { return c.values; }// map operationsconstexpr iterator find(const key_type& x); constexpr const_iterator find(const key_type& x) const; template constexpr iterator find(const K& x); template constexpr const_iterator find(const K& x) const; constexpr size_type count(const key_type& x) const; template constexpr size_type count(const K& x) const; constexpr bool contains(const key_type& x) const; template constexpr bool contains(const K& x) const; constexpr iterator lower_bound(const key_type& x); constexpr const_iterator lower_bound(const key_type& x) const; template constexpr iterator lower_bound(const K& x); template constexpr const_iterator lower_bound(const K& x) const; constexpr iterator upper_bound(const key_type& x); constexpr const_iterator upper_bound(const key_type& x) const; template constexpr iterator upper_bound(const K& x); template constexpr const_iterator upper_bound(const K& x) const; constexpr pair<iterator, iterator> equal_range(const key_type& x); constexpr pair<const_iterator, const_iterator> equal_range(const key_type& x) const; template constexpr pair<iterator, iterator> equal_range(const K& x); templateconstexpr pair<const_iterator, const_iterator> equal_range(const K& x) const; friend constexpr bool operator==(const flat_map& x, const flat_map& y); friend constexpr synth-three-way-result<value_type>operator<=>(const flat_map& x, const flat_map& y); friend constexpr void swap(flat_map& x, flat_map& y) noexcept{ x.swap(y); }private: containers c; // exposition only key_compare compare; // exposition onlystruct key-equiv { // exposition onlyconstexpr key-equiv(key_compare c) : comp(c) { }constexpr bool operator()(const_reference x, const_reference y) const {return !comp(x.first, y.first) && !comp(y.first, x.first); } key_compare comp; }; }; template<class KeyContainer, class MappedContainer, class Compare = less> flat_map(KeyContainer, MappedContainer, Compare = Compare())-> flat_map<typename KeyContainer::value_type, typename MappedContainer::value_type, Compare, KeyContainer, MappedContainer>; template<class KeyContainer, class MappedContainer, class Allocator> flat_map(KeyContainer, MappedContainer, Allocator)-> flat_map<typename KeyContainer::value_type, typename MappedContainer::value_type, less, KeyContainer, MappedContainer>; template<class KeyContainer, class MappedContainer, class Compare, class Allocator> flat_map(KeyContainer, MappedContainer, Compare, Allocator)-> flat_map<typename KeyContainer::value_type, typename MappedContainer::value_type, Compare, KeyContainer, MappedContainer>; template<class KeyContainer, class MappedContainer, class Compare = less> flat_map(sorted_unique_t, KeyContainer, MappedContainer, Compare = Compare())-> flat_map<typename KeyContainer::value_type, typename MappedContainer::value_type, Compare, KeyContainer, MappedContainer>; template<class KeyContainer, class MappedContainer, class Allocator> flat_map(sorted_unique_t, KeyContainer, MappedContainer, Allocator)-> flat_map<typename KeyContainer::value_type, typename MappedContainer::value_type, less, KeyContainer, MappedContainer>; template<class KeyContainer, class MappedContainer, class Compare, class Allocator> flat_map(sorted_unique_t, KeyContainer, MappedContainer, Compare, Allocator)-> flat_map<typename KeyContainer::value_type, typename MappedContainer::value_type, Compare, KeyContainer, MappedContainer>; template<class InputIterator, class Compare = less<iter-key-type>> flat_map(InputIterator, InputIterator, Compare = Compare())-> flat_map<iter-key-type, iter-mapped-type, Compare>; template<class InputIterator, class Compare = less<iter-key-type>> flat_map(sorted_unique_t, InputIterator, InputIterator, Compare = Compare())-> flat_map<iter-key-type, iter-mapped-type, Compare>; template<ranges::input_range R, class Compare = less<range-key-type>, class Allocator = allocator> flat_map(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())-> flat_map<range-key-type, range-mapped-type, Compare, vector<range-key-type, alloc-rebind<Allocator, range-key-type>>, vector<range-mapped-type, alloc-rebind<Allocator, range-mapped-type>>>; template<ranges::input_range R, class Allocator> flat_map(from_range_t, R&&, Allocator)-> flat_map<range-key-type, range-mapped-type, less<range-key-type>, vector<range-key-type, alloc-rebind<Allocator, range-key-type>>, vector<range-mapped-type, alloc-rebind<Allocator, range-mapped-type>>>; template<class Key, class T, class Compare = less> flat_map(initializer_list<pair<Key, T>>, Compare = Compare())-> flat_map<Key, T, Compare>; template<class Key, class T, class Compare = less> flat_map(sorted_unique_t, initializer_list<pair<Key, T>>, Compare = Compare())-> flat_map<Key, T, Compare>; template<class Key, class T, class Compare, class KeyContainer, class MappedContainer, class Allocator>struct uses_allocator<flat_map<Key, T, Compare, KeyContainer, MappedContainer>, Allocator>: bool_constant<uses_allocator_v<KeyContainer, Allocator> && uses_allocator_v<MappedContainer, Allocator>> { };}
The member type containers has the data members and special members specified above.
It has no base classes or members other than those specified.