1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP___NODE_HANDLE
11#define _LIBCPP___NODE_HANDLE
12
13/*
14
15template<unspecified>
16class node-handle {
17public:
18 using value_type = see below; // not present for map containers
19 using key_type = see below; // not present for set containers
20 using mapped_type = see below; // not present for set containers
21 using allocator_type = see below;
22
23private:
24 using container_node_type = unspecified; // exposition only
25 using ator_traits = allocator_traits<allocator_type>; // exposition only
26
27 typename ator_traits::template
28 rebind_traits<container_node_type>::pointer ptr_; // exposition only
29 optional<allocator_type> alloc_; // exposition only
30
31public:
32 // [container.node.cons], constructors, copy, and assignment
33 constexpr node-handle() noexcept : ptr_(), alloc_() {}
34 node-handle(node-handle&&) noexcept;
35 node-handle& operator=(node-handle&&);
36
37 // [container.node.dtor], destructor
38 ~node-handle();
39
40 // [container.node.observers], observers
41 value_type& value() const; // not present for map containers
42 key_type& key() const; // not present for set containers
43 mapped_type& mapped() const; // not present for set containers
44
45 allocator_type get_allocator() const;
46 explicit operator bool() const noexcept;
47 [[nodiscard]] bool empty() const noexcept; // nodiscard since C++20
48
49 // [container.node.modifiers], modifiers
50 void swap(node-handle&)
51 noexcept(ator_traits::propagate_on_container_swap::value ||
52 ator_traits::is_always_equal::value);
53
54 friend void swap(node-handle& x, node-handle& y) noexcept(noexcept(x.swap(y))) {
55 x.swap(y);
56 }
57};
58
59*/
60
61#include <__assert>
62#include <__config>
63#include <__memory/allocator_traits.h>
64#include <__memory/pointer_traits.h>
65#include <optional>
66
67#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
68# pragma GCC system_header
69#endif
70
71_LIBCPP_PUSH_MACROS
72#include <__undef_macros>
73
74_LIBCPP_BEGIN_NAMESPACE_STD
75
76#if _LIBCPP_STD_VER >= 17
77
78// Specialized in __tree & __hash_table for their _NodeType.
79template <class _NodeType, class _Alloc>
80struct __generic_container_node_destructor;
81
82template <class _NodeType, class _Alloc, template <class, class> class _MapOrSetSpecifics>
83class _LIBCPP_TEMPLATE_VIS __basic_node_handle
84 : public _MapOrSetSpecifics< _NodeType, __basic_node_handle<_NodeType, _Alloc, _MapOrSetSpecifics>> {
85 template <class _Tp, class _Compare, class _Allocator>
86 friend class __tree;
87 template <class _Tp, class _Hash, class _Equal, class _Allocator>
88 friend class __hash_table;
89 friend struct _MapOrSetSpecifics< _NodeType, __basic_node_handle<_NodeType, _Alloc, _MapOrSetSpecifics>>;
90
91 typedef allocator_traits<_Alloc> __alloc_traits;
92 typedef __rebind_pointer_t<typename __alloc_traits::void_pointer, _NodeType> __node_pointer_type;
93
94public:
95 typedef _Alloc allocator_type;
96
97private:
98 __node_pointer_type __ptr_ = nullptr;
99 optional<allocator_type> __alloc_;
100
101 _LIBCPP_HIDE_FROM_ABI void __release_ptr() {
102 __ptr_ = nullptr;
103 __alloc_ = std::nullopt;
104 }
105
106 _LIBCPP_HIDE_FROM_ABI void __destroy_node_pointer() {
107 if (__ptr_ != nullptr) {
108 typedef typename __allocator_traits_rebind< allocator_type, _NodeType>::type __node_alloc_type;
109 __node_alloc_type __alloc(*__alloc_);
110 __generic_container_node_destructor<_NodeType, __node_alloc_type>(__alloc, true)(__ptr_);
111 __ptr_ = nullptr;
112 }
113 }
114
115 _LIBCPP_HIDE_FROM_ABI __basic_node_handle(__node_pointer_type __ptr, allocator_type const& __alloc)
116 : __ptr_(__ptr), __alloc_(__alloc) {}
117
118public:
119 _LIBCPP_HIDE_FROM_ABI __basic_node_handle() = default;
120
121 _LIBCPP_HIDE_FROM_ABI __basic_node_handle(__basic_node_handle&& __other) noexcept
122 : __ptr_(__other.__ptr_), __alloc_(std::move(__other.__alloc_)) {
123 __other.__ptr_ = nullptr;
124 __other.__alloc_ = std::nullopt;
125 }
126
127 _LIBCPP_HIDE_FROM_ABI __basic_node_handle& operator=(__basic_node_handle&& __other) {
128 _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
129 __alloc_ == std::nullopt || __alloc_traits::propagate_on_container_move_assignment::value ||
130 __alloc_ == __other.__alloc_,
131 "node_type with incompatible allocator passed to "
132 "node_type::operator=(node_type&&)");
133
134 __destroy_node_pointer();
135 __ptr_ = __other.__ptr_;
136
137 if (__alloc_traits::propagate_on_container_move_assignment::value || __alloc_ == std::nullopt)
138 __alloc_ = std::move(__other.__alloc_);
139
140 __other.__ptr_ = nullptr;
141 __other.__alloc_ = std::nullopt;
142
143 return *this;
144 }
145
146 _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const { return *__alloc_; }
147
148 _LIBCPP_HIDE_FROM_ABI explicit operator bool() const { return __ptr_ != nullptr; }
149
150 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool empty() const { return __ptr_ == nullptr; }
151
152 _LIBCPP_HIDE_FROM_ABI void swap(__basic_node_handle& __other) noexcept(
153 __alloc_traits::propagate_on_container_swap::value || __alloc_traits::is_always_equal::value) {
154 using std::swap;
155 swap(__ptr_, __other.__ptr_);
156 if (__alloc_traits::propagate_on_container_swap::value || __alloc_ == std::nullopt ||
157 __other.__alloc_ == std::nullopt)
158 swap(__alloc_, __other.__alloc_);
159 }
160
161 _LIBCPP_HIDE_FROM_ABI friend void
162 swap(__basic_node_handle& __a, __basic_node_handle& __b) noexcept(noexcept(__a.swap(__b))) {
163 __a.swap(__b);
164 }
165
166 _LIBCPP_HIDE_FROM_ABI ~__basic_node_handle() { __destroy_node_pointer(); }
167};
168
169template <class _NodeType, class _Derived>
170struct __set_node_handle_specifics {
171 typedef typename _NodeType::__node_value_type value_type;
172
173 _LIBCPP_HIDE_FROM_ABI value_type& value() const { return static_cast<_Derived const*>(this)->__ptr_->__get_value(); }
174};
175
176template <class _NodeType, class _Derived>
177struct __map_node_handle_specifics {
178 typedef typename _NodeType::__node_value_type::key_type key_type;
179 typedef typename _NodeType::__node_value_type::mapped_type mapped_type;
180
181 _LIBCPP_HIDE_FROM_ABI key_type& key() const {
182 return static_cast<_Derived const*>(this)->__ptr_->__get_value().__ref().first;
183 }
184
185 _LIBCPP_HIDE_FROM_ABI mapped_type& mapped() const {
186 return static_cast<_Derived const*>(this)->__ptr_->__get_value().__ref().second;
187 }
188};
189
190template <class _NodeType, class _Alloc>
191using __set_node_handle = __basic_node_handle< _NodeType, _Alloc, __set_node_handle_specifics>;
192
193template <class _NodeType, class _Alloc>
194using __map_node_handle = __basic_node_handle< _NodeType, _Alloc, __map_node_handle_specifics>;
195
196template <class _Iterator, class _NodeType>
197struct _LIBCPP_TEMPLATE_VIS __insert_return_type {
198 _Iterator position;
199 bool inserted;
200 _NodeType node;
201};
202
203#endif // _LIBCPP_STD_VER >= 17
204
205_LIBCPP_END_NAMESPACE_STD
206
207_LIBCPP_POP_MACROS
208
209#endif // _LIBCPP___NODE_HANDLE
210