Skip to content

Commit ca72744

Browse files
vinay-deshmukhvinay-deshmukh
committed
Replace __value_ with __get_value() for __tree_node
1 parent 5afe3a4 commit ca72744

File tree

1 file changed

+46
-45
lines changed

1 file changed

+46
-45
lines changed

‎libcxx/include/__tree‎

Lines changed: 46 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -572,7 +572,8 @@ public:
572572

573573
_LIBCPP_HIDE_FROM_ABI void __set_parent(pointer __p) { __parent_ = static_cast<__end_node_pointer>(__p); }
574574

575-
~__tree_node_base() = delete;
575+
_LIBCPP_HIDE_FROM_ABI __tree_node_base() = default;
576+
_LIBCPP_HIDE_FROM_ABI ~__tree_node_base() = default;
576577
__tree_node_base(__tree_node_base const&) = delete;
577578
__tree_node_base& operator=(__tree_node_base const&) = delete;
578579
};
@@ -634,7 +635,7 @@ public:
634635

635636
_LIBCPP_HIDE_FROM_ABI void operator()(pointer __p) _NOEXCEPT {
636637
if (__value_constructed)
637-
__alloc_traits::destroy(__na_, std::addressof(__p->__value_));
638+
__alloc_traits::destroy(__na_, std::addressof(__p->__get_value()));
638639
if (__p)
639640
__alloc_traits::deallocate(__na_, __p, 1);
640641
}
@@ -670,8 +671,8 @@ public:
670671

671672
_LIBCPP_HIDE_FROM_ABI __tree_iterator() _NOEXCEPT : __ptr_(nullptr) {}
672673

673-
_LIBCPP_HIDE_FROM_ABI reference operator*() const { return __get_np()->__value_; }
674-
_LIBCPP_HIDE_FROM_ABI pointer operator->() const { return pointer_traits<pointer>::pointer_to(__get_np()->__value_); }
674+
_LIBCPP_HIDE_FROM_ABI reference operator*() const { return __get_np()->__get_value(); }
675+
_LIBCPP_HIDE_FROM_ABI pointer operator->() const { return pointer_traits<pointer>::pointer_to(__get_np()->__get_value()); }
675676

676677
_LIBCPP_HIDE_FROM_ABI __tree_iterator& operator++() {
677678
__ptr_ = std::__tree_next_iter<__end_node_pointer>(static_cast<__node_base_pointer>(__ptr_));
@@ -732,8 +733,8 @@ public:
732733

733734
_LIBCPP_HIDE_FROM_ABI __tree_const_iterator(__non_const_iterator __p) _NOEXCEPT : __ptr_(__p.__ptr_) {}
734735

735-
_LIBCPP_HIDE_FROM_ABI reference operator*() const { return __get_np()->__value_; }
736-
_LIBCPP_HIDE_FROM_ABI pointer operator->() const { return pointer_traits<pointer>::pointer_to(__get_np()->__value_); }
736+
_LIBCPP_HIDE_FROM_ABI reference operator*() const { return __get_np()->__get_value(); }
737+
_LIBCPP_HIDE_FROM_ABI pointer operator->() const { return pointer_traits<pointer>::pointer_to(__get_np()->__get_value()); }
737738

738739
_LIBCPP_HIDE_FROM_ABI __tree_const_iterator& operator++() {
739740
__ptr_ = std::__tree_next_iter<__end_node_pointer>(static_cast<__node_base_pointer>(__ptr_));
@@ -1246,7 +1247,7 @@ private:
12461247

12471248
auto __right = __ptr->__right_;
12481249

1249-
__node_traits::destroy(__alloc_, std::addressof(__ptr->__value_));
1250+
__node_traits::destroy(__alloc_, std::addressof(__ptr->__get_value()));
12501251
__node_traits::deallocate(__alloc_, __ptr, 1);
12511252

12521253
(*this)(static_cast<__node_pointer>(__right));
@@ -1265,7 +1266,7 @@ private:
12651266
if (!__src)
12661267
return nullptr;
12671268

1268-
__node_holder __new_node = __construct_node(__src->__value_);
1269+
__node_holder __new_node = __construct_node(__src->__get_value());
12691270

12701271
unique_ptr<__node, __tree_deleter> __left(
12711272
__copy_construct_tree(static_cast<__node_pointer>(__src->__left_)), __node_alloc_);
@@ -1296,7 +1297,7 @@ private:
12961297
return nullptr;
12971298
}
12981299

1299-
__assign_value(__dest->__value_, __src->__value_);
1300+
__assign_value(__dest->__get_value(), __src->__get_value());
13001301
__dest->__is_black_ = __src->__is_black_;
13011302

13021303
// If we already have a left node in the destination tree, reuse it and copy-assign recursively
@@ -1437,7 +1438,7 @@ void __tree<_Tp, _Compare, _Allocator>::__assign_multi(_InputIterator __first, _
14371438
if (__size_ != 0) {
14381439
_DetachedTreeCache __cache(this);
14391440
for (; __cache.__get() && __first != __last; ++__first) {
1440-
__assign_value(__cache.__get()->__value_, *__first);
1441+
__assign_value(__cache.__get()->__get_value(), *__first);
14411442
__node_insert_multi(__cache.__get());
14421443
__cache.__advance();
14431444
}
@@ -1529,13 +1530,13 @@ void __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type) {
15291530
if (__size_ != 0) {
15301531
_DetachedTreeCache __cache(this);
15311532
while (__cache.__get() != nullptr && __t.__size_ != 0) {
1532-
__assign_value(__cache.__get()->__value_, std::move(__t.remove(__t.begin())->__value_));
1533+
__assign_value(__cache.__get()->__get_value(), std::move(__t.remove(__t.begin())->__get_value()));
15331534
__node_insert_multi(__cache.__get());
15341535
__cache.__advance();
15351536
}
15361537
}
15371538
while (__t.__size_ != 0) {
1538-
__insert_multi_from_orphaned_node(__e, std::move(__t.remove(__t.begin())->__value_));
1539+
__insert_multi_from_orphaned_node(__e, std::move(__t.remove(__t.begin())->__get_value()));
15391540
}
15401541
}
15411542
}
@@ -1603,7 +1604,7 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_low(__end_node_pointer& __parent,
16031604
__node_pointer __nd = __root();
16041605
if (__nd != nullptr) {
16051606
while (true) {
1606-
if (value_comp()(__nd->__value_, __v)) {
1607+
if (value_comp()(__nd->__get_value(), __v)) {
16071608
if (__nd->__right_ != nullptr)
16081609
__nd = static_cast<__node_pointer>(__nd->__right_);
16091610
else {
@@ -1633,7 +1634,7 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_high(__end_node_pointer& __parent
16331634
__node_pointer __nd = __root();
16341635
if (__nd != nullptr) {
16351636
while (true) {
1636-
if (value_comp()(__v, __nd->__value_)) {
1637+
if (value_comp()(__v, __nd->__get_value())) {
16371638
if (__nd->__left_ != nullptr)
16381639
__nd = static_cast<__node_pointer>(__nd->__left_);
16391640
else {
@@ -1696,15 +1697,15 @@ __tree<_Tp, _Compare, _Allocator>::__find_equal(__end_node_pointer& __parent, co
16961697
__node_base_pointer* __nd_ptr = __root_ptr();
16971698
if (__nd != nullptr) {
16981699
while (true) {
1699-
if (value_comp()(__v, __nd->__value_)) {
1700+
if (value_comp()(__v, __nd->__get_value())) {
17001701
if (__nd->__left_ != nullptr) {
17011702
__nd_ptr = std::addressof(__nd->__left_);
17021703
__nd = static_cast<__node_pointer>(__nd->__left_);
17031704
} else {
17041705
__parent = static_cast<__end_node_pointer>(__nd);
17051706
return __parent->__left_;
17061707
}
1707-
} else if (value_comp()(__nd->__value_, __v)) {
1708+
} else if (value_comp()(__nd->__get_value(), __v)) {
17081709
if (__nd->__right_ != nullptr) {
17091710
__nd_ptr = std::addressof(__nd->__right_);
17101711
__nd = static_cast<__node_pointer>(__nd->__right_);
@@ -1839,7 +1840,7 @@ pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
18391840
__tree<_Tp, _Compare, _Allocator>::__emplace_unique_impl(_Args&&... __args) {
18401841
__node_holder __h = __construct_node(std::forward<_Args>(__args)...);
18411842
__end_node_pointer __parent;
1842-
__node_base_pointer& __child = __find_equal(__parent, __h->__value_);
1843+
__node_base_pointer& __child = __find_equal(__parent, __h->__get_value());
18431844
__node_pointer __r = static_cast<__node_pointer>(__child);
18441845
bool __inserted = false;
18451846
if (__child == nullptr) {
@@ -1857,7 +1858,7 @@ __tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique_impl(const_iterator __p
18571858
__node_holder __h = __construct_node(std::forward<_Args>(__args)...);
18581859
__end_node_pointer __parent;
18591860
__node_base_pointer __dummy;
1860-
__node_base_pointer& __child = __find_equal(__p, __parent, __dummy, __h->__value_);
1861+
__node_base_pointer& __child = __find_equal(__p, __parent, __dummy, __h->__get_value());
18611862
__node_pointer __r = static_cast<__node_pointer>(__child);
18621863
if (__child == nullptr) {
18631864
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
@@ -1872,7 +1873,7 @@ typename __tree<_Tp, _Compare, _Allocator>::iterator
18721873
__tree<_Tp, _Compare, _Allocator>::__emplace_multi(_Args&&... __args) {
18731874
__node_holder __h = __construct_node(std::forward<_Args>(__args)...);
18741875
__end_node_pointer __parent;
1875-
__node_base_pointer& __child = __find_leaf_high(__parent, __h->__value_);
1876+
__node_base_pointer& __child = __find_leaf_high(__parent, __h->__get_value());
18761877
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
18771878
return iterator(static_cast<__node_pointer>(__h.release()));
18781879
}
@@ -1883,7 +1884,7 @@ typename __tree<_Tp, _Compare, _Allocator>::iterator
18831884
__tree<_Tp, _Compare, _Allocator>::__emplace_hint_multi(const_iterator __p, _Args&&... __args) {
18841885
__node_holder __h = __construct_node(std::forward<_Args>(__args)...);
18851886
__end_node_pointer __parent;
1886-
__node_base_pointer& __child = __find_leaf(__p, __parent, __h->__value_);
1887+
__node_base_pointer& __child = __find_leaf(__p, __parent, __h->__get_value());
18871888
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
18881889
return iterator(static_cast<__node_pointer>(__h.release()));
18891890
}
@@ -1896,7 +1897,7 @@ __tree<_Tp, _Compare, _Allocator>::__node_assign_unique(const value_type& __v, _
18961897
__node_pointer __r = static_cast<__node_pointer>(__child);
18971898
bool __inserted = false;
18981899
if (__child == nullptr) {
1899-
__assign_value(__nd->__value_, __v);
1900+
__assign_value(__nd->__get_value(), __v);
19001901
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
19011902
__r = __nd;
19021903
__inserted = true;
@@ -1908,7 +1909,7 @@ template <class _Tp, class _Compare, class _Allocator>
19081909
typename __tree<_Tp, _Compare, _Allocator>::iterator
19091910
__tree<_Tp, _Compare, _Allocator>::__node_insert_multi(__node_pointer __nd) {
19101911
__end_node_pointer __parent;
1911-
__node_base_pointer& __child = __find_leaf_high(__parent, __nd->__value_);
1912+
__node_base_pointer& __child = __find_leaf_high(__parent, __nd->__get_value());
19121913
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
19131914
return iterator(__nd);
19141915
}
@@ -1917,7 +1918,7 @@ template <class _Tp, class _Compare, class _Allocator>
19171918
typename __tree<_Tp, _Compare, _Allocator>::iterator
19181919
__tree<_Tp, _Compare, _Allocator>::__node_insert_multi(const_iterator __p, __node_pointer __nd) {
19191920
__end_node_pointer __parent;
1920-
__node_base_pointer& __child = __find_leaf(__p, __parent, __nd->__value_);
1921+
__node_base_pointer& __child = __find_leaf(__p, __parent, __nd->__get_value());
19211922
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
19221923
return iterator(__nd);
19231924
}
@@ -1944,7 +1945,7 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_unique(_NodeHandle&& __n
19441945

19451946
__node_pointer __ptr = __nh.__ptr_;
19461947
__end_node_pointer __parent;
1947-
__node_base_pointer& __child = __find_equal(__parent, __ptr->__value_);
1948+
__node_base_pointer& __child = __find_equal(__parent, __ptr->__get_value());
19481949
if (__child != nullptr)
19491950
return _InsertReturnType{iterator(static_cast<__node_pointer>(__child)), false, std::move(__nh)};
19501951

@@ -1963,7 +1964,7 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_unique(const_iterator __
19631964
__node_pointer __ptr = __nh.__ptr_;
19641965
__end_node_pointer __parent;
19651966
__node_base_pointer __dummy;
1966-
__node_base_pointer& __child = __find_equal(__hint, __parent, __dummy, __ptr->__value_);
1967+
__node_base_pointer& __child = __find_equal(__hint, __parent, __dummy, __ptr->__get_value());
19671968
__node_pointer __r = static_cast<__node_pointer>(__child);
19681969
if (__child == nullptr) {
19691970
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
@@ -1998,7 +1999,7 @@ _LIBCPP_HIDE_FROM_ABI void __tree<_Tp, _Compare, _Allocator>::__node_handle_merg
19981999
for (typename _Tree::iterator __i = __source.begin(); __i != __source.end();) {
19992000
__node_pointer __src_ptr = __i.__get_np();
20002001
__end_node_pointer __parent;
2001-
__node_base_pointer& __child = __find_equal(__parent, __src_ptr->__value_);
2002+
__node_base_pointer& __child = __find_equal(__parent, __src_ptr->__get_value());
20022003
++__i;
20032004
if (__child != nullptr)
20042005
continue;
@@ -2015,7 +2016,7 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_multi(_NodeHandle&& __nh
20152016
return end();
20162017
__node_pointer __ptr = __nh.__ptr_;
20172018
__end_node_pointer __parent;
2018-
__node_base_pointer& __child = __find_leaf_high(__parent, __ptr->__value_);
2019+
__node_base_pointer& __child = __find_leaf_high(__parent, __ptr->__get_value());
20192020
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
20202021
__nh.__release_ptr();
20212022
return iterator(__ptr);
@@ -2030,7 +2031,7 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_multi(const_iterator __h
20302031

20312032
__node_pointer __ptr = __nh.__ptr_;
20322033
__end_node_pointer __parent;
2033-
__node_base_pointer& __child = __find_leaf(__hint, __parent, __ptr->__value_);
2034+
__node_base_pointer& __child = __find_leaf(__hint, __parent, __ptr->__get_value());
20342035
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
20352036
__nh.__release_ptr();
20362037
return iterator(__ptr);
@@ -2044,7 +2045,7 @@ _LIBCPP_HIDE_FROM_ABI void __tree<_Tp, _Compare, _Allocator>::__node_handle_merg
20442045
for (typename _Tree::iterator __i = __source.begin(); __i != __source.end();) {
20452046
__node_pointer __src_ptr = __i.__get_np();
20462047
__end_node_pointer __parent;
2047-
__node_base_pointer& __child = __find_leaf_high(__parent, __src_ptr->__value_);
2048+
__node_base_pointer& __child = __find_leaf_high(__parent, __src_ptr->__get_value());
20482049
++__i;
20492050
__source.__remove_node_pointer(__src_ptr);
20502051
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__src_ptr));
@@ -2099,9 +2100,9 @@ typename __tree<_Tp, _Compare, _Allocator>::size_type
20992100
__tree<_Tp, _Compare, _Allocator>::__count_unique(const _Key& __k) const {
21002101
__node_pointer __rt = __root();
21012102
while (__rt != nullptr) {
2102-
if (value_comp()(__k, __rt->__value_)) {
2103+
if (value_comp()(__k, __rt->__get_value())) {
21032104
__rt = static_cast<__node_pointer>(__rt->__left_);
2104-
} else if (value_comp()(__rt->__value_, __k))
2105+
} else if (value_comp()(__rt->__get_value(), __k))
21052106
__rt = static_cast<__node_pointer>(__rt->__right_);
21062107
else
21072108
return 1;
@@ -2116,10 +2117,10 @@ __tree<_Tp, _Compare, _Allocator>::__count_multi(const _Key& __k) const {
21162117
__end_node_pointer __result = __end_node();
21172118
__node_pointer __rt = __root();
21182119
while (__rt != nullptr) {
2119-
if (value_comp()(__k, __rt->__value_)) {
2120+
if (value_comp()(__k, __rt->__get_value())) {
21202121
__result = static_cast<__end_node_pointer>(__rt);
21212122
__rt = static_cast<__node_pointer>(__rt->__left_);
2122-
} else if (value_comp()(__rt->__value_, __k))
2123+
} else if (value_comp()(__rt->__get_value(), __k))
21232124
__rt = static_cast<__node_pointer>(__rt->__right_);
21242125
else
21252126
return std::distance(
@@ -2134,7 +2135,7 @@ template <class _Key>
21342135
typename __tree<_Tp, _Compare, _Allocator>::iterator
21352136
__tree<_Tp, _Compare, _Allocator>::__lower_bound(const _Key& __v, __node_pointer __root, __end_node_pointer __result) {
21362137
while (__root != nullptr) {
2137-
if (!value_comp()(__root->__value_, __v)) {
2138+
if (!value_comp()(__root->__get_value(), __v)) {
21382139
__result = static_cast<__end_node_pointer>(__root);
21392140
__root = static_cast<__node_pointer>(__root->__left_);
21402141
} else
@@ -2148,7 +2149,7 @@ template <class _Key>
21482149
typename __tree<_Tp, _Compare, _Allocator>::const_iterator __tree<_Tp, _Compare, _Allocator>::__lower_bound(
21492150
const _Key& __v, __node_pointer __root, __end_node_pointer __result) const {
21502151
while (__root != nullptr) {
2151-
if (!value_comp()(__root->__value_, __v)) {
2152+
if (!value_comp()(__root->__get_value(), __v)) {
21522153
__result = static_cast<__end_node_pointer>(__root);
21532154
__root = static_cast<__node_pointer>(__root->__left_);
21542155
} else
@@ -2162,7 +2163,7 @@ template <class _Key>
21622163
typename __tree<_Tp, _Compare, _Allocator>::iterator
21632164
__tree<_Tp, _Compare, _Allocator>::__upper_bound(const _Key& __v, __node_pointer __root, __end_node_pointer __result) {
21642165
while (__root != nullptr) {
2165-
if (value_comp()(__v, __root->__value_)) {
2166+
if (value_comp()(__v, __root->__get_value())) {
21662167
__result = static_cast<__end_node_pointer>(__root);
21672168
__root = static_cast<__node_pointer>(__root->__left_);
21682169
} else
@@ -2176,7 +2177,7 @@ template <class _Key>
21762177
typename __tree<_Tp, _Compare, _Allocator>::const_iterator __tree<_Tp, _Compare, _Allocator>::__upper_bound(
21772178
const _Key& __v, __node_pointer __root, __end_node_pointer __result) const {
21782179
while (__root != nullptr) {
2179-
if (value_comp()(__v, __root->__value_)) {
2180+
if (value_comp()(__v, __root->__get_value())) {
21802181
__result = static_cast<__end_node_pointer>(__root);
21812182
__root = static_cast<__node_pointer>(__root->__left_);
21822183
} else
@@ -2193,10 +2194,10 @@ __tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k) {
21932194
__end_node_pointer __result = __end_node();
21942195
__node_pointer __rt = __root();
21952196
while (__rt != nullptr) {
2196-
if (value_comp()(__k, __rt->__value_)) {
2197+
if (value_comp()(__k, __rt->__get_value())) {
21972198
__result = static_cast<__end_node_pointer>(__rt);
21982199
__rt = static_cast<__node_pointer>(__rt->__left_);
2199-
} else if (value_comp()(__rt->__value_, __k))
2200+
} else if (value_comp()(__rt->__get_value(), __k))
22002201
__rt = static_cast<__node_pointer>(__rt->__right_);
22012202
else
22022203
return _Pp(iterator(__rt),
@@ -2215,10 +2216,10 @@ __tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k) const {
22152216
__end_node_pointer __result = __end_node();
22162217
__node_pointer __rt = __root();
22172218
while (__rt != nullptr) {
2218-
if (value_comp()(__k, __rt->__value_)) {
2219+
if (value_comp()(__k, __rt->__get_value())) {
22192220
__result = static_cast<__end_node_pointer>(__rt);
22202221
__rt = static_cast<__node_pointer>(__rt->__left_);
2221-
} else if (value_comp()(__rt->__value_, __k))
2222+
} else if (value_comp()(__rt->__get_value(), __k))
22222223
__rt = static_cast<__node_pointer>(__rt->__right_);
22232224
else
22242225
return _Pp(
@@ -2237,10 +2238,10 @@ __tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k) {
22372238
__end_node_pointer __result = __end_node();
22382239
__node_pointer __rt = __root();
22392240
while (__rt != nullptr) {
2240-
if (value_comp()(__k, __rt->__value_)) {
2241+
if (value_comp()(__k, __rt->__get_value())) {
22412242
__result = static_cast<__end_node_pointer>(__rt);
22422243
__rt = static_cast<__node_pointer>(__rt->__left_);
2243-
} else if (value_comp()(__rt->__value_, __k))
2244+
} else if (value_comp()(__rt->__get_value(), __k))
22442245
__rt = static_cast<__node_pointer>(__rt->__right_);
22452246
else
22462247
return _Pp(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__end_node_pointer>(__rt)),
@@ -2258,10 +2259,10 @@ __tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k) const {
22582259
__end_node_pointer __result = __end_node();
22592260
__node_pointer __rt = __root();
22602261
while (__rt != nullptr) {
2261-
if (value_comp()(__k, __rt->__value_)) {
2262+
if (value_comp()(__k, __rt->__get_value())) {
22622263
__result = static_cast<__end_node_pointer>(__rt);
22632264
__rt = static_cast<__node_pointer>(__rt->__left_);
2264-
} else if (value_comp()(__rt->__value_, __k))
2265+
} else if (value_comp()(__rt->__get_value(), __k))
22652266
__rt = static_cast<__node_pointer>(__rt->__right_);
22662267
else
22672268
return _Pp(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__end_node_pointer>(__rt)),

0 commit comments

Comments
 (0)