xref: /freebsd/contrib/llvm-project/libcxx/include/__node_handle (revision 258a0d760aa8b42899a000e30f610f900a402556) 
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_BEGIN_NAMESPACE_STD
72
73#if _LIBCPP_STD_VER > 14
74
75// Specialized in __tree & __hash_table for their _NodeType.
76template <class _NodeType, class _Alloc>
77struct __generic_container_node_destructor;
78
79template <class _NodeType, class _Alloc,
80          template <class, class> class _MapOrSetSpecifics>
81class _LIBCPP_TEMPLATE_VIS __basic_node_handle
82    : public _MapOrSetSpecifics<
83          _NodeType,
84          __basic_node_handle<_NodeType, _Alloc, _MapOrSetSpecifics>>
85{
86    template <class _Tp, class _Compare, class _Allocator>
87        friend class __tree;
88    template <class _Tp, class _Hash, class _Equal, class _Allocator>
89        friend class __hash_table;
90    friend struct _MapOrSetSpecifics<
91        _NodeType, __basic_node_handle<_NodeType, _Alloc, _MapOrSetSpecifics>>;
92
93    typedef allocator_traits<_Alloc> __alloc_traits;
94    typedef __rebind_pointer_t<typename __alloc_traits::void_pointer,
95                                      _NodeType>
96        __node_pointer_type;
97
98public:
99    typedef _Alloc allocator_type;
100
101private:
102    __node_pointer_type __ptr_ = nullptr;
103    optional<allocator_type> __alloc_;
104
105    _LIBCPP_INLINE_VISIBILITY
106    void __release_ptr()
107    {
108        __ptr_ = nullptr;
109        __alloc_ = _VSTD::nullopt;
110    }
111
112    _LIBCPP_INLINE_VISIBILITY
113    void __destroy_node_pointer()
114    {
115        if (__ptr_ != nullptr)
116        {
117            typedef typename __allocator_traits_rebind<
118                allocator_type, _NodeType>::type __node_alloc_type;
119            __node_alloc_type __alloc(*__alloc_);
120            __generic_container_node_destructor<_NodeType, __node_alloc_type>(
121                __alloc, true)(__ptr_);
122            __ptr_ = nullptr;
123        }
124    }
125
126    _LIBCPP_INLINE_VISIBILITY
127    __basic_node_handle(__node_pointer_type __ptr,
128                        allocator_type const& __alloc)
129            : __ptr_(__ptr), __alloc_(__alloc)
130    {
131    }
132
133public:
134    _LIBCPP_INLINE_VISIBILITY
135    __basic_node_handle() = default;
136
137    _LIBCPP_INLINE_VISIBILITY
138    __basic_node_handle(__basic_node_handle&& __other) noexcept
139            : __ptr_(__other.__ptr_),
140              __alloc_(_VSTD::move(__other.__alloc_))
141    {
142        __other.__ptr_ = nullptr;
143        __other.__alloc_ = _VSTD::nullopt;
144    }
145
146    _LIBCPP_INLINE_VISIBILITY
147    __basic_node_handle& operator=(__basic_node_handle&& __other)
148    {
149        _LIBCPP_ASSERT(
150            __alloc_ == _VSTD::nullopt ||
151            __alloc_traits::propagate_on_container_move_assignment::value ||
152            __alloc_ == __other.__alloc_,
153            "node_type with incompatible allocator passed to "
154            "node_type::operator=(node_type&&)");
155
156        __destroy_node_pointer();
157        __ptr_ = __other.__ptr_;
158
159        if (__alloc_traits::propagate_on_container_move_assignment::value ||
160            __alloc_ == _VSTD::nullopt)
161            __alloc_ = _VSTD::move(__other.__alloc_);
162
163        __other.__ptr_ = nullptr;
164        __other.__alloc_ = _VSTD::nullopt;
165
166        return *this;
167    }
168
169    _LIBCPP_INLINE_VISIBILITY
170    allocator_type get_allocator() const { return *__alloc_; }
171
172    _LIBCPP_INLINE_VISIBILITY
173    explicit operator bool() const { return __ptr_ != nullptr; }
174
175    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
176    bool empty() const { return __ptr_ == nullptr; }
177
178    _LIBCPP_INLINE_VISIBILITY
179    void swap(__basic_node_handle& __other) noexcept(
180        __alloc_traits::propagate_on_container_swap::value ||
181        __alloc_traits::is_always_equal::value)
182    {
183        using _VSTD::swap;
184        swap(__ptr_, __other.__ptr_);
185        if (__alloc_traits::propagate_on_container_swap::value ||
186            __alloc_ == _VSTD::nullopt || __other.__alloc_ == _VSTD::nullopt)
187            swap(__alloc_, __other.__alloc_);
188    }
189
190    _LIBCPP_INLINE_VISIBILITY
191    friend void swap(__basic_node_handle& __a, __basic_node_handle& __b)
192        noexcept(noexcept(__a.swap(__b))) { __a.swap(__b); }
193
194    _LIBCPP_INLINE_VISIBILITY
195    ~__basic_node_handle()
196    {
197        __destroy_node_pointer();
198    }
199};
200
201template <class _NodeType, class _Derived>
202struct __set_node_handle_specifics
203{
204    typedef typename _NodeType::__node_value_type value_type;
205
206    _LIBCPP_INLINE_VISIBILITY
207    value_type& value() const
208    {
209        return static_cast<_Derived const*>(this)->__ptr_->__value_;
210    }
211};
212
213template <class _NodeType, class _Derived>
214struct __map_node_handle_specifics
215{
216    typedef typename _NodeType::__node_value_type::key_type key_type;
217    typedef typename _NodeType::__node_value_type::mapped_type mapped_type;
218
219    _LIBCPP_INLINE_VISIBILITY
220    key_type& key() const
221    {
222        return static_cast<_Derived const*>(this)->
223            __ptr_->__value_.__ref().first;
224    }
225
226    _LIBCPP_INLINE_VISIBILITY
227    mapped_type& mapped() const
228    {
229        return static_cast<_Derived const*>(this)->
230            __ptr_->__value_.__ref().second;
231    }
232};
233
234template <class _NodeType, class _Alloc>
235using __set_node_handle =
236    __basic_node_handle< _NodeType, _Alloc, __set_node_handle_specifics>;
237
238template <class _NodeType, class _Alloc>
239using __map_node_handle =
240    __basic_node_handle< _NodeType, _Alloc, __map_node_handle_specifics>;
241
242template <class _Iterator, class _NodeType>
243struct _LIBCPP_TEMPLATE_VIS __insert_return_type
244{
245    _Iterator position;
246    bool inserted;
247    _NodeType node;
248};
249
250#endif // _LIBCPP_STD_VER > 14
251
252_LIBCPP_END_NAMESPACE_STD
253
254#endif  // _LIBCPP___NODE_HANDLE
255