This header is part of the containers library.
[edit] Synopsis#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 hive
template<class T, class Allocator = allocator<T>>
class hive;
// swap
template<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>>;
}
}[edit] Class template std::hive
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/destroy
constexpr hive() noexcept(noexcept(Allocator())) : hive(Allocator()) {}
constexpr explicit hive(const Allocator&) noexcept;
constexpr explicit 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() const noexcept;
// iterators
iterator begin() noexcept;
const_iterator begin() const noexcept;
iterator end() noexcept;
const_iterator end() const noexcept;
reverse_iterator rbegin() noexcept;
const_reverse_iterator rbegin() const noexcept;
reverse_iterator rend() noexcept;
const_reverse_iterator rend() const noexcept;
const_iterator cbegin() const noexcept;
const_iterator cend() const noexcept;
const_reverse_iterator crbegin() const noexcept;
const_reverse_iterator crend() const noexcept;
// size/capacity
bool empty() const noexcept;
size_type size() const noexcept;
size_type max_size() const noexcept;
size_type capacity() const noexcept;
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() const noexcept;
static constexpr hive_limits block_capacity_default_limits() noexcept;
static constexpr hive_limits block_capacity_hard_limits() noexcept;
void reshape(hive_limits block_limits);
// modifiers
template<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 operations
void 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) const noexcept;
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>;
}
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4