12 KiB
[flat.set.defn]
23 Containers library [containers]
23.6 Container adaptors [container.adaptors]
23.6.11 Class template flat_set [flat.set]
23.6.11.2 Definition [flat.set.defn]
namespace std {template<class Key, class Compare = less, class KeyContainer = vector>class flat_set {public:// typesusing key_type = Key; using value_type = Key; using key_compare = Compare; using value_compare = Compare; using reference = value_type&; using const_reference = const value_type&; using size_type = typename KeyContainer::size_type; using difference_type = typename KeyContainer::difference_type; 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 container_type = KeyContainer; // [flat.set.cons], constructorsconstexpr flat_set() : flat_set(key_compare()) { }constexpr explicit flat_set(const key_compare& comp): c(), compare(comp) { }constexpr explicit flat_set(container_type cont, const key_compare& comp = key_compare()); constexpr flat_set(sorted_unique_t, container_type cont, const key_compare& comp = key_compare()): c(std::move(cont)), compare(comp) { }templateconstexpr flat_set(InputIterator first, InputIterator last, const key_compare& comp = key_compare()): c(), compare(comp){ insert(first, last); }templateconstexpr flat_set(sorted_unique_t, InputIterator first, InputIterator last, const key_compare& comp = key_compare()): c(first, last), compare(comp) { }template<container-compatible-range<value_type> R>constexpr flat_set(from_range_t, R&& rg): flat_set(from_range, std::forward(rg), key_compare()) { }template<container-compatible-range<value_type> R>constexpr flat_set(from_range_t, R&& rg, const key_compare& comp): flat_set(comp){ insert_range(std::forward(rg)); }constexpr flat_set(initializer_list<value_type> il, const key_compare& comp = key_compare()): flat_set(il.begin(), il.end(), comp) { }constexpr flat_set(sorted_unique_t, initializer_list<value_type> il, const key_compare& comp = key_compare()): flat_set(sorted_unique, il.begin(), il.end(), comp) { }// [flat.set.cons.alloc], constructors with allocatorstemplateconstexpr explicit flat_set(const Alloc& a); templateconstexpr flat_set(const key_compare& comp, const Alloc& a); templateconstexpr flat_set(const container_type& cont, const Alloc& a); templateconstexpr flat_set(const container_type& cont, const key_compare& comp, const Alloc& a); templateconstexpr flat_set(sorted_unique_t, const container_type& cont, const Alloc& a); templateconstexpr flat_set(sorted_unique_t, const container_type& cont, const key_compare& comp, const Alloc& a); templateconstexpr flat_set(const flat_set&, const Alloc& a); templateconstexpr flat_set(flat_set&&, const Alloc& a); template<class InputIterator, class Alloc>constexpr flat_set(InputIterator first, InputIterator last, const Alloc& a); template<class InputIterator, class Alloc>constexpr flat_set(InputIterator first, InputIterator last, const key_compare& comp, const Alloc& a); template<class InputIterator, class Alloc>constexpr flat_set(sorted_unique_t, InputIterator first, InputIterator last, const Alloc& a); template<class InputIterator, class Alloc>constexpr flat_set(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_set(from_range_t, R&& rg, const Alloc& a); template<container-compatible-range<value_type> R, class Alloc>constexpr flat_set(from_range_t, R&& rg, const key_compare& comp, const Alloc& a); templateconstexpr flat_set(initializer_list<value_type> il, const Alloc& a); templateconstexpr flat_set(initializer_list<value_type> il, const key_compare& comp, const Alloc& a); templateconstexpr flat_set(sorted_unique_t, initializer_list<value_type> il, const Alloc& a); templateconstexpr flat_set(sorted_unique_t, initializer_list<value_type> il, const key_compare& comp, const Alloc& a); constexpr flat_set& 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; // capacityconstexpr bool empty() const noexcept; constexpr size_type size() const noexcept; constexpr size_type max_size() const noexcept; // [flat.set.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)); }template constexpr pair<iterator, bool> insert(K&& 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 iterator insert(const_iterator hint, K&& x); 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 container_type extract() &&; constexpr void replace(container_type&&); 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_set& y) noexcept; constexpr void clear() noexcept; // observersconstexpr key_compare key_comp() const; constexpr value_compare value_comp() const; // set 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; templateconstexpr 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_set& x, const flat_set& y); friend constexpr synth-three-way-result<value_type>operator<=>(const flat_set& x, const flat_set& y); friend constexpr void swap(flat_set& x, flat_set& y) noexcept { x.swap(y); }private: container_type c; // exposition only key_compare compare; // exposition only}; template<class KeyContainer, class Compare = less> flat_set(KeyContainer, Compare = Compare())-> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>; template<class KeyContainer, class Allocator> flat_set(KeyContainer, Allocator)-> flat_set<typename KeyContainer::value_type, less, KeyContainer>; template<class KeyContainer, class Compare, class Allocator> flat_set(KeyContainer, Compare, Allocator)-> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>; template<class KeyContainer, class Compare = less> flat_set(sorted_unique_t, KeyContainer, Compare = Compare())-> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>; template<class KeyContainer, class Allocator> flat_set(sorted_unique_t, KeyContainer, Allocator)-> flat_set<typename KeyContainer::value_type, less, KeyContainer>; template<class KeyContainer, class Compare, class Allocator> flat_set(sorted_unique_t, KeyContainer, Compare, Allocator)-> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>; template<class InputIterator, class Compare = less<iter-value-type>> flat_set(InputIterator, InputIterator, Compare = Compare())-> flat_set<iter-value-type, Compare>; template<class InputIterator, class Compare = less<iter-value-type>> flat_set(sorted_unique_t, InputIterator, InputIterator, Compare = Compare())-> flat_set<iter-value-type, Compare>; template<ranges::input_range R, class Compare = less<ranges::range_value_t>, class Allocator = allocator<ranges::range_value_t>> flat_set(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())-> flat_set<ranges::range_value_t, Compare, vector<ranges::range_value_t, alloc-rebind<Allocator, ranges::range_value_t>>>; template<ranges::input_range R, class Allocator> flat_set(from_range_t, R&&, Allocator)-> flat_set<ranges::range_value_t, less<ranges::range_value_t>, vector<ranges::range_value_t, alloc-rebind<Allocator, ranges::range_value_t>>>; template<class Key, class Compare = less> flat_set(initializer_list, Compare = Compare())-> flat_set<Key, Compare>; template<class Key, class Compare = less> flat_set(sorted_unique_t, initializer_list, Compare = Compare())-> flat_set<Key, Compare>; template<class Key, class Compare, class KeyContainer, class Allocator>struct uses_allocator<flat_set<Key, Compare, KeyContainer>, Allocator>: bool_constant<uses_allocator_v<KeyContainer, Allocator>> { };}