libcxx/include/__node_handle

   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
  15 template<unspecified>
  16 class node-handle {
  17 public:
  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
  23 private:
  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
  31 public:
  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.
  79 template <class _NodeType, class _Alloc>
  80 struct __generic_container_node_destructor;
  81
  82 template <class _NodeType, class _Alloc, template <class, class> class _MapOrSetSpecifics>
  83 class _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
  94 public:
  95   typedef _Alloc allocator_type;
  96
  97 private:
  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
 118 public:
 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   _LIBCPP_NODISCARD_AFTER_CXX17 _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
 169 template <class _NodeType, class _Derived>
 170 struct __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
 176 template <class _NodeType, class _Derived>
 177 struct __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
 190 template <class _NodeType, class _Alloc>
 191 using __set_node_handle = __basic_node_handle< _NodeType, _Alloc, __set_node_handle_specifics>;
 192
 193 template <class _NodeType, class _Alloc>
 194 using __map_node_handle = __basic_node_handle< _NodeType, _Alloc, __map_node_handle_specifics>;
 195
 196 template <class _Iterator, class _NodeType>
 197 struct _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