• Log in

#include <compare>#include <initializer_list> namespace std{ struct hive_limits{    size_t min;    size_t max;constexpr hive_limits(size_t minimum, size_t maximum)noexcept: min(minimum), max(maximum){}}; // class template hivetemplate<class T,class Allocator= allocator<T>>class hive; // swaptemplate<class T,class Allocator>void swap(hive<T, Allocator>& x, hive<T, Allocator>& y)noexcept(noexcept(x.swap(y))); template<class T,class Allocator,class U= T>typename hive<T, Allocator>::size_type erase(hive<T, Allocator>& c,const U& value); template<class T,class Allocator,class Predicate>typename hive<T, Allocator>::size_type erase_if(hive<T, Allocator>& c, Predicate pred); namespace pmr{template<class T>using hive= std::hive<T, polymorphic_allocator<T>>;}}

namespace std{template<class T,class Allocator>class hive{public:// types:using value_type= T;using allocator_type= Allocator;using pointer= allocator_traits<Allocator>::pointer;using const_pointer= allocator_traits<Allocator>::const_pointer;using reference= value_type&;using const_reference=const value_type&;using size_type=/* implementation-defined */;using difference_type=/* implementation-defined */;using iterator=/* implementation-defined */;using const_iterator=/* implementation-defined */;using reverse_iterator=std::reverse_iterator<iterator>;using const_reverse_iterator=std::reverse_iterator<const_iterator>; // construct/copy/destroyconstexpr hive()noexcept(noexcept(Allocator())): hive(Allocator()){}constexprexplicit hive(const Allocator&)noexcept;constexprexplicit hive(hive_limits block_limits): hive(block_limits, Allocator()){}constexpr hive(hive_limits block_limits,const Allocator&);explicit hive(size_type n,const Allocator&= Allocator());    hive(size_type n,const T& value,const Allocator&= Allocator());    hive(size_type n,const T& value, hive_limits block_limits,const Allocator&= Allocator());template<class InputIter>    hive(InputIter first, InputIter last,const Allocator&= Allocator());template<class InputIter>    hive(InputIter first, InputIter last, hive_limits block_limits,const Allocator&= Allocator());template<container-compatible-range<T> R>    hive(from_range_t, R&& rg,const Allocator&= Allocator());template<container-compatible-range<T> R>    hive(from_range_t, R&& rg, hive_limits block_limits,const Allocator&= Allocator());    hive(const hive& other);    hive(hive&& other)noexcept;    hive(const hive& other,const type_identity_t<Allocator>& alloc);    hive(hive&& other,const type_identity_t<Allocator>& alloc);    hive(initializer_list<T> il,const Allocator&= Allocator());    hive(initializer_list<T> il, hive_limits block_limits,const Allocator&= Allocator());     ~hive();    hive& operator=(const hive& other);    hive& operator=(hive&& other)noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value|| allocator_traits<Allocator>::is_always_equal::value);    hive& operator=(initializer_list<T>);template<class InputIter>void assign(InputIter first, InputIter last);template<container-compatible-range<T> R>void assign_range(R&& rg);void assign(size_type n,const T& value);void assign(initializer_list<T> il);    allocator_type get_allocator()constnoexcept; // iterators    iterator begin()noexcept;    const_iterator begin()constnoexcept;    iterator end()noexcept;    const_iterator end()constnoexcept;    reverse_iterator rbegin()noexcept;    const_reverse_iterator rbegin()constnoexcept;    reverse_iterator rend()noexcept;    const_reverse_iterator rend()constnoexcept;     const_iterator cbegin()constnoexcept;    const_iterator cend()constnoexcept;    const_reverse_iterator crbegin()constnoexcept;    const_reverse_iterator crend()constnoexcept; // size/capacitybool empty()constnoexcept;    size_type size()constnoexcept;    size_type max_size()constnoexcept;    size_type capacity()constnoexcept;void reserve(size_type n);void shrink_to_fit();void trim_capacity()noexcept;void trim_capacity(size_type n)noexcept;constexpr hive_limits block_capacity_limits()constnoexcept;staticconstexpr hive_limits block_capacity_default_limits()noexcept;staticconstexpr hive_limits block_capacity_hard_limits()noexcept;void reshape(hive_limits block_limits); // modifierstemplate<class...Args>    iterator emplace(Args&&...args);template<class...Args>    iterator emplace_hint(const_iterator hint, Args&&...args);    iterator insert(const T& x);    iterator insert(T&& x);    iterator insert(const_iterator hint,const T& x);    iterator insert(const_iterator hint, T&& x);void insert(initializer_list<T> il);template<container-compatible-range<T> R>void insert_range(R&& rg);template<class InputIter>void insert(InputIter first, InputIter last);void insert(size_type n,const T& x);     iterator erase(const_iterator position);    iterator erase(const_iterator first, const_iterator last);void swap(hive&)noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value|| allocator_traits<Allocator>::is_always_equal::value);void clear()noexcept; // hive operationsvoid splice(hive& other);void splice(hive&& other);template<class BinaryPredicate= equal_to<T>>    size_type unique(BinaryPredicate binary_pred= BinaryPredicate()); template<class Compare= less<T>>void sort(Compare comp= Compare());     iterator get_iterator(const_pointer p)noexcept;    const_iterator get_iterator(const_pointer p)constnoexcept; private:// exposition only    hive_limits current_limits_=/* implementation-defined */}; template<class InputIter,class Allocator= allocator</*iter-value-type*/<InputIter>>  hive(InputIter, InputIter, Allocator= Allocator())-> hive</*iter-value-type*/<InputIter>, Allocator>; template<class InputIter,class Allocator= allocator</*iter-value-type*/<InputIter>>  hive(InputIter, InputIter, hive_limits, Allocator= Allocator())-> hive</*iter-value-type*/<InputIter>, Allocator>; template<ranges::input_range R,class Allocator= allocator<ranges::range_value_t<R>>>  hive(from_range_t, R&&, Allocator= Allocator())-> hive<ranges::range_value_t<R>, Allocator>; template<ranges::input_range R,class Allocator= allocator<ranges::range_value_t<R>>>  hive(from_range_t, R&&, hive_limits, Allocator= Allocator())-> hive<ranges::range_value_t<R>, Allocator>;}