|
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 | };
|
|
8066 | 8105 |
|
8067 | 8106 | \rSec3[hive.cons]{Constructors, copy, and assignment}
|
8068 | 8107 |
|
| 8108 | +\indexlibraryctor{hive}% |
8069 | 8109 | \begin{itemdecl}
|
8070 | 8110 | constexpr explicit hive(const Allocator&) noexcept;
|
8071 | 8111 | \end{itemdecl}
|
|
8080 | 8120 | Constant.
|
8081 | 8121 | \end{itemdescr}
|
8082 | 8122 |
|
| 8123 | +\indexlibraryctor{hive}% |
8083 | 8124 | \begin{itemdecl}
|
8084 | 8125 | constexpr hive(hive_limits block_limits, const Allocator&);
|
8085 | 8126 | \end{itemdecl}
|
|
8095 | 8136 | Constant.
|
8096 | 8137 | \end{itemdescr}
|
8097 | 8138 |
|
| 8139 | +\indexlibraryctor{hive}% |
8098 | 8140 | \begin{itemdecl}
|
8099 | 8141 | explicit hive(size_type n, const Allocator& = Allocator());
|
8100 | 8142 | hive(size_type n, hive_limits block_limits, const Allocator& = Allocator());
|
|
8117 | 8159 | Linear in \tcode{n}.
|
8118 | 8160 | \end{itemdescr}
|
8119 | 8161 |
|
| 8162 | +\indexlibraryctor{hive}% |
8120 | 8163 | \begin{itemdecl}
|
8121 | 8164 | hive(size_type n, const T& value, const Allocator& = Allocator());
|
8122 | 8165 | hive(size_type n, const T& value, hive_limits block_limits, const Allocator& = Allocator());
|
|
8139 | 8182 | Linear in \tcode{n}.
|
8140 | 8183 | \end{itemdescr}
|
8141 | 8184 |
|
| 8185 | +\indexlibraryctor{hive}% |
8142 | 8186 | \begin{itemdecl}
|
8143 | 8187 | template<class InputIterator>
|
8144 | 8188 | hive(InputIterator first, InputIterator last, const Allocator& = Allocator());
|
|
8160 | 8204 | Linear in \tcode{distance(first, last)}.
|
8161 | 8205 | \end{itemdescr}
|
8162 | 8206 |
|
| 8207 | +\indexlibraryctor{hive}% |
8163 | 8208 | \begin{itemdecl}
|
8164 | 8209 | template<@\exposconcept{container-compatible-range}@<T> R>
|
8165 | 8210 | hive(from_range_t, R&& rg, const Allocator& = Allocator());
|
|
8180 | 8225 | Linear in \tcode{ranges::distance(rg)}.
|
8181 | 8226 | \end{itemdescr}
|
8182 | 8227 |
|
| 8228 | +\indexlibraryctor{hive}% |
8183 | 8229 | \begin{itemdecl}
|
8184 | 8230 | hive(const hive& x);
|
8185 | 8231 | hive(const hive& x, const type_identity_t<Allocator>& alloc);
|
|
8201 | 8247 | Linear in \tcode{x.size()}.
|
8202 | 8248 | \end{itemdescr}
|
8203 | 8249 |
|
| 8250 | +\indexlibraryctor{hive}% |
8204 | 8251 | \begin{itemdecl}
|
8205 | 8252 | hive(hive&& x);
|
8206 | 8253 | hive(hive&& x, const type_identity_t<Allocator>& alloc);
|
|
8242 | 8289 | Otherwise constant.
|
8243 | 8290 | \end{itemdescr}
|
8244 | 8291 |
|
| 8292 | +\indexlibraryctor{hive}% |
8245 | 8293 | \begin{itemdecl}
|
8246 | 8294 | hive(initializer_list<T> il, const Allocator& = Allocator());
|
8247 | 8295 | hive(initializer_list<T> il, hive_limits block_limits, const Allocator& = Allocator());
|
|
8264 | 8312 | Linear in \tcode{il.size()}.
|
8265 | 8313 | \end{itemdescr}
|
8266 | 8314 |
|
| 8315 | +\indexlibrarymember{operator=}{hive}% |
8267 | 8316 | \begin{itemdecl}
|
8268 | 8317 | hive& operator=(const hive& x);
|
8269 | 8318 | \end{itemdecl}
|
|
8287 | 8336 | Linear in \tcode{size() + x.size()}.
|
8288 | 8337 | \end{itemdescr}
|
8289 | 8338 |
|
| 8339 | +\indexlibrarymember{operator=}{hive}% |
8290 | 8340 | \begin{itemdecl}
|
8291 | 8341 | hive& operator=(hive&& x)
|
8292 | 8342 | noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
|
|
8349 | 8399 |
|
8350 | 8400 | \rSec3[hive.capacity]{Capacity}
|
8351 | 8401 |
|
| 8402 | +\indexlibrarymember{capacity}{hive}% |
8352 | 8403 | \begin{itemdecl}
|
8353 | 8404 | size_type capacity() const noexcept;
|
8354 | 8405 | \end{itemdecl}
|
|
8364 | 8415 | Constant.
|
8365 | 8416 | \end{itemdescr}
|
8366 | 8417 |
|
| 8418 | +\indexlibrarymember{reserve}{hive}% |
8367 | 8419 | \begin{itemdecl}
|
8368 | 8420 | void reserve(size_type n);
|
8369 | 8421 | \end{itemdecl}
|
|
8394 | 8446 | as well as the past-the-end iterator, remain valid.
|
8395 | 8447 | \end{itemdescr}
|
8396 | 8448 |
|
| 8449 | +\indexlibrarymember{shrink_to_fit}{hive}% |
8397 | 8450 | \begin{itemdecl}
|
8398 | 8451 | void shrink_to_fit();
|
8399 | 8452 | \end{itemdecl}
|
|
8431 | 8484 | as well as the past-the-end iterator, are invalidated.
|
8432 | 8485 | \end{itemdescr}
|
8433 | 8486 |
|
| 8487 | +\indexlibrarymember{trim_capacity}{hive}% |
8434 | 8488 | \begin{itemdecl}
|
8435 | 8489 | void trim_capacity() noexcept;
|
8436 | 8490 | void trim_capacity(size_type n) noexcept;
|
|
8453 | 8507 | as well as the past-the-end iterator, remain valid.
|
8454 | 8508 | \end{itemdescr}
|
8455 | 8509 |
|
| 8510 | +\indexlibrarymember{block_capacity_limits}{hive}% |
8456 | 8511 | \begin{itemdecl}
|
8457 | 8512 | constexpr hive_limits block_capacity_limits() const noexcept;
|
8458 | 8513 | \end{itemdecl}
|
|
8467 | 8522 | Constant.
|
8468 | 8523 | \end{itemdescr}
|
8469 | 8524 |
|
| 8525 | +\indexlibrarymember{block_capacity_default_limits}{hive}% |
8470 | 8526 | \begin{itemdecl}
|
8471 | 8527 | static constexpr hive_limits block_capacity_default_limits() noexcept;
|
8472 | 8528 | \end{itemdecl}
|
|
8483 | 8539 | Constant.
|
8484 | 8540 | \end{itemdescr}
|
8485 | 8541 |
|
| 8542 | +\indexlibrarymember{block_capacity_hard_limits}{hive}% |
8486 | 8543 | \begin{itemdecl}
|
8487 | 8544 | static constexpr hive_limits block_capacity_hard_limits() noexcept;
|
8488 | 8545 | \end{itemdecl}
|
|
8499 | 8556 | Constant.
|
8500 | 8557 | \end{itemdescr}
|
8501 | 8558 |
|
| 8559 | +\indexlibrarymember{reshape}{hive}% |
8502 | 8560 | \begin{itemdecl}
|
8503 | 8561 | void reshape(hive_limits block_limits);
|
8504 | 8562 | \end{itemdecl}
|
|
8546 | 8604 |
|
8547 | 8605 | \rSec3[hive.modifiers]{Modifiers}
|
8548 | 8606 |
|
| 8607 | +\indexlibrarymember{emplace}{hive}% |
8549 | 8608 | \begin{itemdecl}
|
8550 | 8609 | template<class... Args> iterator emplace(Args&&... args);
|
8551 | 8610 | template<class... Args> iterator emplace_hint(const_iterator hint, Args&&... args);
|
|
8579 | 8638 | Invalidates the past-the-end iterator.
|
8580 | 8639 | \end{itemdescr}
|
8581 | 8640 |
|
| 8641 | +\indexlibrarymember{insert}{hive}% |
8582 | 8642 | \begin{itemdecl}
|
8583 | 8643 | iterator insert(const T& x);
|
8584 | 8644 | iterator insert(const_iterator hint, const T& x);
|
|
8595 | 8655 | \end{note}
|
8596 | 8656 | \end{itemdescr}
|
8597 | 8657 |
|
| 8658 | +\indexlibrarymember{insert}{hive}% |
8598 | 8659 | \begin{itemdecl}
|
8599 | 8660 | void insert(initializer_list<T> rg);
|
8600 | 8661 | template<@\exposconcept{container-compatible-range}@<T> R>
|
|
8623 | 8684 | If an element is inserted, invalidates the past-the-end iterator.
|
8624 | 8685 | \end{itemdescr}
|
8625 | 8686 |
|
| 8687 | +\indexlibrarymember{insert}{hive}% |
8626 | 8688 | \begin{itemdecl}
|
8627 | 8689 | void insert(size_type n, const T& x);
|
8628 | 8690 | \end{itemdecl}
|
|
8646 | 8708 | If an element is inserted, invalidates the past-the-end iterator.
|
8647 | 8709 | \end{itemdescr}
|
8648 | 8710 |
|
| 8711 | +\indexlibrarymember{insert}{hive}% |
8649 | 8712 | \begin{itemdecl}
|
8650 | 8713 | template<class InputIterator>
|
8651 | 8714 | void insert(InputIterator first, InputIterator last);
|
|
8657 | 8720 | Equivalent to \tcode{insert_range(ranges::subrange(first, last))}.
|
8658 | 8721 | \end{itemdescr}
|
8659 | 8722 |
|
| 8723 | +\indexlibrarymember{erase}{hive}% |
8660 | 8724 | \begin{itemdecl}
|
8661 | 8725 | iterator erase(const_iterator position);
|
8662 | 8726 | iterator erase(const_iterator first, const_iterator last);
|
|
8678 | 8742 | also invalidates the past-the-end iterator.
|
8679 | 8743 | \end{itemdescr}
|
8680 | 8744 |
|
| 8745 | +\indexlibrarymember{swap}{hive}% |
8681 | 8746 | \begin{itemdecl}
|
8682 | 8747 | void swap(hive& x)
|
8683 | 8748 | noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
|
|
8706 | 8771 | are the same as those of \tcode{next(i, n)} and \tcode{prev(i, n)}, respectively.
|
8707 | 8772 | For \tcode{sort}, the definitions and requirements in \ref{alg.sorting} apply.
|
8708 | 8773 |
|
| 8774 | +\indexlibrarymember{splice}{hive}% |
8709 | 8775 | \begin{itemdecl}
|
8710 | 8776 | void splice(hive& x);
|
8711 | 8777 | void splice(hive&& x);
|
|
8744 | 8810 | invalidates the past-the-end iterator for both \tcode{x} and \tcode{*this}.
|
8745 | 8811 | \end{itemdescr}
|
8746 | 8812 |
|
| 8813 | +\indexlibrarymember{unique}{hive}% |
8747 | 8814 | \begin{itemdecl}
|
8748 | 8815 | template<class BinaryPredicate = equal_to<T>>
|
8749 | 8816 | size_type unique(BinaryPredicate binary_pred = BinaryPredicate());
|
|
8785 | 8852 | also invalidates the past-the-end iterator.
|
8786 | 8853 | \end{itemdescr}
|
8787 | 8854 |
|
| 8855 | +\indexlibrarymember{sort}{hive}% |
8788 | 8856 | \begin{itemdecl}
|
8789 | 8857 | template<class Compare = less<T>>
|
8790 | 8858 | void sort(Compare comp = Compare());
|
|
8816 | 8884 | \end{note}
|
8817 | 8885 | \end{itemdescr}
|
8818 | 8886 |
|
| 8887 | +\indexlibrarymember{get_iterator}{hive}% |
8819 | 8888 | \begin{itemdecl}
|
8820 | 8889 | iterator get_iterator(const_pointer p) noexcept;
|
8821 | 8890 | const_iterator get_iterator(const_pointer p) const noexcept;
|
|
8838 | 8907 |
|
8839 | 8908 | \rSec3[hive.erasure]{Erasure}
|
8840 | 8909 |
|
| 8910 | +\indexlibrarymember{erase}{hive}% |
8841 | 8911 | \begin{itemdecl}
|
8842 | 8912 | template<class T, class Allocator, class U>
|
8843 | 8913 | typename hive<T, Allocator>::size_type
|
|
8853 | 8923 | \end{codeblock}
|
8854 | 8924 | \end{itemdescr}
|
8855 | 8925 |
|
| 8926 | +\indexlibrarymember{erase_if}{hive}% |
8856 | 8927 | \begin{itemdecl}
|
8857 | 8928 | template<class T, class Allocator, class Predicate>
|
8858 | 8929 | typename hive<T, Allocator>::size_type
|
|
0 commit comments