|
112 | 112 | \indexlibrarymemberx{array}{#1}%
|
113 | 113 | \indexlibrarymemberx{deque}{#1}%
|
114 | 114 | \indexlibrarymemberx{forward_list}{#1}%
|
| 115 | +\indexlibrarymemberx{hive}{#1}% |
115 | 116 | \indexlibrarymemberx{list}{#1}%
|
116 | 117 | \indexlibrarymemberx{vector}{#1}%
|
117 | 118 | \indexlibrarymemberx{map}{#1}%
|
|
426 | 427 | Constant.
|
427 | 428 | \end{itemdescr}
|
428 | 429 |
|
429 |
| -\indexcont{operator==}% |
| 430 | +% hive is excluded here |
| 431 | +\indexlibrarymisc{\idxcode{operator==}}{containers}% |
| 432 | +\indexlibrarymemberx{array}{operator==}% |
| 433 | +\indexlibrarymemberx{deque}{operator==}% |
| 434 | +\indexlibrarymemberx{forward_list}{operator==}% |
| 435 | +\indexlibrarymemberx{list}{operator==}% |
| 436 | +\indexlibrarymemberx{vector}{operator==}% |
| 437 | +\indexlibrarymemberx{map}{operator==}% |
| 438 | +\indexlibrarymemberx{set}{operator==}% |
| 439 | +\indexlibrarymemberx{multiset}{operator==}% |
| 440 | +\indexlibrarymemberx{multimap}{operator==}% |
| 441 | +\indexlibrarymemberx{unordered_map}{operator==}% |
| 442 | +\indexlibrarymemberx{unordered_set}{operator==}% |
| 443 | +\indexlibrarymemberx{unordered_multiset}{operator==}% |
| 444 | +\indexlibrarymemberx{unordered_multimap}{operator==}% |
| 445 | +\indexlibrarymemberx{flat_map}{operator==}% |
| 446 | +\indexlibrarymemberx{flat_set}{operator==}% |
| 447 | +\indexlibrarymemberx{flat_multiset}{operator==}% |
| 448 | +\indexlibrarymemberx{flat_multimap}{operator==}% |
430 | 449 | \begin{itemdecl}
|
431 | 450 | c == b
|
432 | 451 | \end{itemdecl}
|
|
457 | 476 | \tcode{==} is an equivalence relation.
|
458 | 477 | \end{itemdescr}
|
459 | 478 |
|
460 |
| -\indexcont{operator"!=}% |
| 479 | +% hive is excluded here |
| 480 | +\indexlibrarymisc{\idxcode{operator"!=}}{containers}% |
| 481 | +\indexlibrarymemberx{array}{operator"!=}% |
| 482 | +\indexlibrarymemberx{deque}{operator"!=}% |
| 483 | +\indexlibrarymemberx{forward_list}{operator"!=}% |
| 484 | +\indexlibrarymemberx{list}{operator"!=}% |
| 485 | +\indexlibrarymemberx{vector}{operator"!=}% |
| 486 | +\indexlibrarymemberx{map}{operator"!=}% |
| 487 | +\indexlibrarymemberx{set}{operator"!=}% |
| 488 | +\indexlibrarymemberx{multiset}{operator"!=}% |
| 489 | +\indexlibrarymemberx{multimap}{operator"!=}% |
| 490 | +\indexlibrarymemberx{unordered_map}{operator"!=}% |
| 491 | +\indexlibrarymemberx{unordered_set}{operator"!=}% |
| 492 | +\indexlibrarymemberx{unordered_multiset}{operator"!=}% |
| 493 | +\indexlibrarymemberx{unordered_multimap}{operator"!=}% |
| 494 | +\indexlibrarymemberx{flat_map}{operator"!=}% |
| 495 | +\indexlibrarymemberx{flat_set}{operator"!=}% |
| 496 | +\indexlibrarymemberx{flat_multiset}{operator"!=}% |
| 497 | +\indexlibrarymemberx{flat_multimap}{operator"!=}% |
461 | 498 | \begin{itemdecl}
|
462 | 499 | c != b
|
463 | 500 | \end{itemdecl}
|
|
727 | 764 | \indexlibrarymisc{\idxcode{#1}}{reversible containers}%
|
728 | 765 | \indexlibrarymemberx{array}{#1}%
|
729 | 766 | \indexlibrarymemberx{deque}{#1}%
|
| 767 | +\indexlibrarymemberx{hive}{#1}% |
730 | 768 | \indexlibrarymemberx{list}{#1}%
|
731 | 769 | \indexlibrarymemberx{vector}{#1}%
|
732 | 770 | \indexlibrarymemberx{map}{#1}%
|
|
1038 | 1076 | \indexlibrarymisc{\idxcode{#1}}{allocator-aware containers}%
|
1039 | 1077 | \indexlibrarymemberx{deque}{#1}%
|
1040 | 1078 | \indexlibrarymemberx{forward_list}{#1}%
|
| 1079 | +\indexlibrarymemberx{hive}{#1}% |
1041 | 1080 | \indexlibrarymemberx{list}{#1}%
|
1042 | 1081 | \indexlibrarymemberx{vector}{#1}%
|
1043 | 1082 | \indexlibrarymemberx{map}{#1}%
|
|
7810 | 7849 | #include <compare> // see \ref{compare.syn}
|
7811 | 7850 |
|
7812 | 7851 | namespace std {
|
7813 |
| - struct hive_limits { |
7814 |
| - size_t min; |
7815 |
| - size_t max; |
| 7852 | + struct @\libglobal{hive_limits}@ { |
| 7853 | + size_t @\libmember{min}{hive_limits}@; |
| 7854 | + size_t @\libmember{max}{hive_limits}@; |
7816 | 7855 | constexpr hive_limits(size_t minimum, size_t maximum) noexcept
|
7817 | 7856 | : min(minimum), max(maximum) {}
|
7818 | 7857 | };
|
|
8062 | 8101 |
|
8063 | 8102 | \rSec3[hive.cons]{Constructors, copy, and assignment}
|
8064 | 8103 |
|
| 8104 | +\indexlibraryctor{hive}% |
8065 | 8105 | \begin{itemdecl}
|
8066 | 8106 | constexpr explicit hive(const Allocator&) noexcept;
|
8067 | 8107 | \end{itemdecl}
|
|
8076 | 8116 | Constant.
|
8077 | 8117 | \end{itemdescr}
|
8078 | 8118 |
|
| 8119 | +\indexlibraryctor{hive}% |
8079 | 8120 | \begin{itemdecl}
|
8080 | 8121 | constexpr hive(hive_limits block_limits, const Allocator&);
|
8081 | 8122 | \end{itemdecl}
|
|
8091 | 8132 | Constant.
|
8092 | 8133 | \end{itemdescr}
|
8093 | 8134 |
|
| 8135 | +\indexlibraryctor{hive}% |
8094 | 8136 | \begin{itemdecl}
|
8095 | 8137 | explicit hive(size_type n, const Allocator& = Allocator());
|
8096 | 8138 | hive(size_type n, hive_limits block_limits, const Allocator& = Allocator());
|
|
8113 | 8155 | Linear in \tcode{n}.
|
8114 | 8156 | \end{itemdescr}
|
8115 | 8157 |
|
| 8158 | +\indexlibraryctor{hive}% |
8116 | 8159 | \begin{itemdecl}
|
8117 | 8160 | hive(size_type n, const T& value, const Allocator& = Allocator());
|
8118 | 8161 | hive(size_type n, const T& value, hive_limits block_limits, const Allocator& = Allocator());
|
|
8135 | 8178 | Linear in \tcode{n}.
|
8136 | 8179 | \end{itemdescr}
|
8137 | 8180 |
|
| 8181 | +\indexlibraryctor{hive}% |
8138 | 8182 | \begin{itemdecl}
|
8139 | 8183 | template<class InputIterator>
|
8140 | 8184 | hive(InputIterator first, InputIterator last, const Allocator& = Allocator());
|
|
8156 | 8200 | Linear in \tcode{distance(first, last)}.
|
8157 | 8201 | \end{itemdescr}
|
8158 | 8202 |
|
| 8203 | +\indexlibraryctor{hive}% |
8159 | 8204 | \begin{itemdecl}
|
8160 | 8205 | template<@\exposconcept{container-compatible-range}@<T> R>
|
8161 | 8206 | hive(from_range_t, R&& rg, const Allocator& = Allocator());
|
|
8176 | 8221 | Linear in \tcode{ranges::distance(rg)}.
|
8177 | 8222 | \end{itemdescr}
|
8178 | 8223 |
|
| 8224 | +\indexlibraryctor{hive}% |
8179 | 8225 | \begin{itemdecl}
|
8180 | 8226 | hive(const hive& x);
|
8181 | 8227 | hive(const hive& x, const type_identity_t<Allocator>& alloc);
|
|
8197 | 8243 | Linear in \tcode{x.size()}.
|
8198 | 8244 | \end{itemdescr}
|
8199 | 8245 |
|
| 8246 | +\indexlibraryctor{hive}% |
8200 | 8247 | \begin{itemdecl}
|
8201 | 8248 | hive(hive&& x);
|
8202 | 8249 | hive(hive&& x, const type_identity_t<Allocator>& alloc);
|
|
8238 | 8285 | Otherwise constant.
|
8239 | 8286 | \end{itemdescr}
|
8240 | 8287 |
|
| 8288 | +\indexlibraryctor{hive}% |
8241 | 8289 | \begin{itemdecl}
|
8242 | 8290 | hive(initializer_list<T> il, const Allocator& = Allocator());
|
8243 | 8291 | hive(initializer_list<T> il, hive_limits block_limits, const Allocator& = Allocator());
|
|
8260 | 8308 | Linear in \tcode{il.size()}.
|
8261 | 8309 | \end{itemdescr}
|
8262 | 8310 |
|
| 8311 | +\indexlibrarymember{operator=}{hive}% |
8263 | 8312 | \begin{itemdecl}
|
8264 | 8313 | hive& operator=(const hive& x);
|
8265 | 8314 | \end{itemdecl}
|
|
8283 | 8332 | Linear in \tcode{size() + x.size()}.
|
8284 | 8333 | \end{itemdescr}
|
8285 | 8334 |
|
| 8335 | +\indexlibrarymember{operator=}{hive}% |
8286 | 8336 | \begin{itemdecl}
|
8287 | 8337 | hive& operator=(hive&& x)
|
8288 | 8338 | noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
|
|
8345 | 8395 |
|
8346 | 8396 | \rSec3[hive.capacity]{Capacity}
|
8347 | 8397 |
|
| 8398 | +\indexlibrarymember{capacity}{hive}% |
8348 | 8399 | \begin{itemdecl}
|
8349 | 8400 | size_type capacity() const noexcept;
|
8350 | 8401 | \end{itemdecl}
|
|
8360 | 8411 | Constant.
|
8361 | 8412 | \end{itemdescr}
|
8362 | 8413 |
|
| 8414 | +\indexlibrarymember{reserve}{hive}% |
8363 | 8415 | \begin{itemdecl}
|
8364 | 8416 | void reserve(size_type n);
|
8365 | 8417 | \end{itemdecl}
|
|
8390 | 8442 | as well as the past-the-end iterator, remain valid.
|
8391 | 8443 | \end{itemdescr}
|
8392 | 8444 |
|
| 8445 | +\indexlibrarymember{shrink_to_fit}{hive}% |
8393 | 8446 | \begin{itemdecl}
|
8394 | 8447 | void shrink_to_fit();
|
8395 | 8448 | \end{itemdecl}
|
|
8427 | 8480 | as well as the past-the-end iterator, are invalidated.
|
8428 | 8481 | \end{itemdescr}
|
8429 | 8482 |
|
| 8483 | +\indexlibrarymember{trim_capacity}{hive}% |
8430 | 8484 | \begin{itemdecl}
|
8431 | 8485 | void trim_capacity() noexcept;
|
8432 | 8486 | void trim_capacity(size_type n) noexcept;
|
|
8449 | 8503 | as well as the past-the-end iterator, remain valid.
|
8450 | 8504 | \end{itemdescr}
|
8451 | 8505 |
|
| 8506 | +\indexlibrarymember{block_capacity_limits}{hive}% |
8452 | 8507 | \begin{itemdecl}
|
8453 | 8508 | constexpr hive_limits block_capacity_limits() const noexcept;
|
8454 | 8509 | \end{itemdecl}
|
|
8463 | 8518 | Constant.
|
8464 | 8519 | \end{itemdescr}
|
8465 | 8520 |
|
| 8521 | +\indexlibrarymember{block_capacity_default_limits}{hive}% |
8466 | 8522 | \begin{itemdecl}
|
8467 | 8523 | static constexpr hive_limits block_capacity_default_limits() noexcept;
|
8468 | 8524 | \end{itemdecl}
|
|
8479 | 8535 | Constant.
|
8480 | 8536 | \end{itemdescr}
|
8481 | 8537 |
|
| 8538 | +\indexlibrarymember{block_capacity_hard_limits}{hive}% |
8482 | 8539 | \begin{itemdecl}
|
8483 | 8540 | static constexpr hive_limits block_capacity_hard_limits() noexcept;
|
8484 | 8541 | \end{itemdecl}
|
|
8495 | 8552 | Constant.
|
8496 | 8553 | \end{itemdescr}
|
8497 | 8554 |
|
| 8555 | +\indexlibrarymember{reshape}{hive}% |
8498 | 8556 | \begin{itemdecl}
|
8499 | 8557 | void reshape(hive_limits block_limits);
|
8500 | 8558 | \end{itemdecl}
|
|
8542 | 8600 |
|
8543 | 8601 | \rSec3[hive.modifiers]{Modifiers}
|
8544 | 8602 |
|
| 8603 | +\indexlibrarymember{emplace}{hive}% |
8545 | 8604 | \begin{itemdecl}
|
8546 | 8605 | template<class... Args> iterator emplace(Args&&... args);
|
8547 | 8606 | template<class... Args> iterator emplace_hint(const_iterator hint, Args&&... args);
|
|
8575 | 8634 | Invalidates the past-the-end iterator.
|
8576 | 8635 | \end{itemdescr}
|
8577 | 8636 |
|
| 8637 | +\indexlibrarymember{insert}{hive}% |
8578 | 8638 | \begin{itemdecl}
|
8579 | 8639 | iterator insert(const T& x);
|
8580 | 8640 | iterator insert(const_iterator hint, const T& x);
|
|
8591 | 8651 | \end{note}
|
8592 | 8652 | \end{itemdescr}
|
8593 | 8653 |
|
| 8654 | +\indexlibrarymember{insert}{hive}% |
8594 | 8655 | \begin{itemdecl}
|
8595 | 8656 | void insert(initializer_list<T> rg);
|
8596 | 8657 | template<@\exposconcept{container-compatible-range}@<T> R>
|
|
8619 | 8680 | If an element is inserted, invalidates the past-the-end iterator.
|
8620 | 8681 | \end{itemdescr}
|
8621 | 8682 |
|
| 8683 | +\indexlibrarymember{insert}{hive}% |
8622 | 8684 | \begin{itemdecl}
|
8623 | 8685 | void insert(size_type n, const T& x);
|
8624 | 8686 | \end{itemdecl}
|
|
8642 | 8704 | If an element is inserted, invalidates the past-the-end iterator.
|
8643 | 8705 | \end{itemdescr}
|
8644 | 8706 |
|
| 8707 | +\indexlibrarymember{insert}{hive}% |
8645 | 8708 | \begin{itemdecl}
|
8646 | 8709 | template<class InputIterator>
|
8647 | 8710 | void insert(InputIterator first, InputIterator last);
|
|
8653 | 8716 | Equivalent to \tcode{insert_range(ranges::subrange(first, last))}.
|
8654 | 8717 | \end{itemdescr}
|
8655 | 8718 |
|
| 8719 | +\indexlibrarymember{erase}{hive}% |
8656 | 8720 | \begin{itemdecl}
|
8657 | 8721 | iterator erase(const_iterator position);
|
8658 | 8722 | iterator erase(const_iterator first, const_iterator last);
|
|
8674 | 8738 | also invalidates the past-the-end iterator.
|
8675 | 8739 | \end{itemdescr}
|
8676 | 8740 |
|
| 8741 | +\indexlibrarymember{swap}{hive}% |
8677 | 8742 | \begin{itemdecl}
|
8678 | 8743 | void swap(hive& x)
|
8679 | 8744 | noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
|
|
8702 | 8767 | are the same as those of \tcode{next(i, n)} and \tcode{prev(i, n)}, respectively.
|
8703 | 8768 | For \tcode{sort}, the definitions and requirements in \ref{alg.sorting} apply.
|
8704 | 8769 |
|
| 8770 | +\indexlibrarymember{splice}{hive}% |
8705 | 8771 | \begin{itemdecl}
|
8706 | 8772 | void splice(hive& x);
|
8707 | 8773 | void splice(hive&& x);
|
|
8740 | 8806 | invalidates the past-the-end iterator for both \tcode{x} and \tcode{*this}.
|
8741 | 8807 | \end{itemdescr}
|
8742 | 8808 |
|
| 8809 | +\indexlibrarymember{unique}{hive}% |
8743 | 8810 | \begin{itemdecl}
|
8744 | 8811 | template<class BinaryPredicate = equal_to<T>>
|
8745 | 8812 | size_type unique(BinaryPredicate binary_pred = BinaryPredicate());
|
|
8781 | 8848 | also invalidates the past-the-end iterator.
|
8782 | 8849 | \end{itemdescr}
|
8783 | 8850 |
|
| 8851 | +\indexlibrarymember{sort}{hive}% |
8784 | 8852 | \begin{itemdecl}
|
8785 | 8853 | template<class Compare = less<T>>
|
8786 | 8854 | void sort(Compare comp = Compare());
|
|
8812 | 8880 | \end{note}
|
8813 | 8881 | \end{itemdescr}
|
8814 | 8882 |
|
| 8883 | +\indexlibrarymember{get_iterator}{hive}% |
8815 | 8884 | \begin{itemdecl}
|
8816 | 8885 | iterator get_iterator(const_pointer p) noexcept;
|
8817 | 8886 | const_iterator get_iterator(const_pointer p) const noexcept;
|
|
8834 | 8903 |
|
8835 | 8904 | \rSec3[hive.erasure]{Erasure}
|
8836 | 8905 |
|
| 8906 | +\indexlibrarymember{erase}{hive}% |
8837 | 8907 | \begin{itemdecl}
|
8838 | 8908 | template<class T, class Allocator, class U>
|
8839 | 8909 | typename hive<T, Allocator>::size_type
|
|
8849 | 8919 | \end{codeblock}
|
8850 | 8920 | \end{itemdescr}
|
8851 | 8921 |
|
| 8922 | +\indexlibrarymember{erase_if}{hive}% |
8852 | 8923 | \begin{itemdecl}
|
8853 | 8924 | template<class T, class Allocator, class Predicate>
|
8854 | 8925 | typename hive<T, Allocator>::size_type
|
|
0 commit comments