Merge pull request #960 from igchor/merge_stable_1.11_into_master

Merge stable 1.11 into master

Author: lukaszstolarczuk

include/libpmemobj++/detail/template_helpers.hpp

@@ -11,9 +11,6 @@
 
 #include <type_traits>
 
-#include <libpmemobj++/container/basic_string.hpp>
-#include <libpmemobj++/experimental/inline_string.hpp>
-
 namespace pmem
 {
 
@@ -47,31 +44,6 @@ using is_transparent = typename Compare::is_transparent;
 template <typename Compare>
 using has_is_transparent = detail::supports<Compare, is_transparent>;
 
-/* Check if type is pmem::obj::basic_inline_string */
-template <typename>
-struct is_inline_string : std::false_type {
-};
-
-template <typename CharT, typename Traits>
-struct is_inline_string<obj::experimental::basic_inline_string<CharT, Traits>>
-    : std::true_type {
-};
-
-/* Check if type is pmem::obj::basic_string or
- * pmem::obj::basic_inline_string */
-template <typename>
-struct is_string : std::false_type {
-};
-
-template <typename CharT, typename Traits>
-struct is_string<obj::basic_string<CharT, Traits>> : std::true_type {
-};
-
-template <typename CharT, typename Traits>
-struct is_string<obj::experimental::basic_inline_string<CharT, Traits>>
-    : std::true_type {
-};
-
 } /* namespace detail */
 
 } /* namespace pmem */

include/libpmemobj++/experimental/inline_string.hpp

@@ -433,6 +433,20 @@ struct total_sizeof<basic_inline_string<CharT, Traits>> {
 };
 } /* namespace experimental */
 } /* namespace obj */
+
+namespace detail
+{
+/* Check if type is pmem::obj::basic_inline_string */
+template <typename>
+struct is_inline_string : std::false_type {
+};
+
+template <typename CharT, typename Traits>
+struct is_inline_string<obj::experimental::basic_inline_string<CharT, Traits>>
+    : std::true_type {
+};
+} /* namespace detail */
+
 } /* namespace pmem */
 
 #endif /* LIBPMEMOBJ_CPP_INLINE_STRING_HPP */

include/libpmemobj++/experimental/radix_tree.hpp

@@ -415,46 +415,46 @@ struct radix_tree<Key, Value, BytesView>::leaf {
 	const Key &key() const;
 	const Value &value() const;
 
-private:
-	friend class radix_tree<Key, Value, BytesView>;
-
-	leaf() = default;
-
-	template <typename... Args>
-	static persistent_ptr<leaf> make(tagged_node_ptr parent,
-					 Args &&... args);
-
-	static persistent_ptr<leaf> make_internal();
+	static persistent_ptr<leaf> make(tagged_node_ptr parent);
 
 	template <typename... Args1, typename... Args2>
 	static persistent_ptr<leaf>
-	make_internal(std::piecewise_construct_t pc,
-		      std::tuple<Args1...> first_args,
-		      std::tuple<Args2...> second_args);
-
-	template <typename K, typename V>
-	static persistent_ptr<leaf> make_internal(K &&k, V &&v);
+	make(tagged_node_ptr parent, std::piecewise_construct_t pc,
+	     std::tuple<Args1...> first_args, std::tuple<Args2...> second_args);
 	template <typename K, typename V>
-	static persistent_ptr<leaf> make_internal(const K &k, const V &v);
-
+	static persistent_ptr<leaf> make(tagged_node_ptr parent, K &&k, V &&v);
+	static persistent_ptr<leaf> make(tagged_node_ptr parent, const Key &k,
+					 const Value &v);
+	template <typename K, typename... Args>
+	static persistent_ptr<leaf> make_key_args(tagged_node_ptr parent, K &&k,
+						  Args &&... args);
 	template <typename K, typename V>
-	static persistent_ptr<leaf> make_internal(detail::pair<K, V> &&p);
+	static persistent_ptr<leaf> make(tagged_node_ptr parent,
+					 detail::pair<K, V> &&p);
 	template <typename K, typename V>
-	static persistent_ptr<leaf> make_internal(const detail::pair<K, V> &p);
-
+	static persistent_ptr<leaf> make(tagged_node_ptr parent,
+					 const detail::pair<K, V> &p);
 	template <typename K, typename V>
-	static persistent_ptr<leaf> make_internal(std::pair<K, V> &&p);
+	static persistent_ptr<leaf> make(tagged_node_ptr parent,
+					 std::pair<K, V> &&p);
 	template <typename K, typename V>
-	static persistent_ptr<leaf> make_internal(const std::pair<K, V> &p);
+	static persistent_ptr<leaf> make(tagged_node_ptr parent,
+					 const std::pair<K, V> &p);
+	static persistent_ptr<leaf> make(tagged_node_ptr parent,
+					 const leaf &other);
+
+private:
+	friend class radix_tree<Key, Value, BytesView>;
+
+	leaf() = default;
 
 	template <typename... Args1, typename... Args2, size_t... I1,
 		  size_t... I2>
-	static persistent_ptr<leaf> make_internal(
-		std::piecewise_construct_t, std::tuple<Args1...> &first_args,
-		std::tuple<Args2...> &second_args,
-		detail::index_sequence<I1...>, detail::index_sequence<I2...>);
-
-	static persistent_ptr<leaf> make_internal(const leaf &other);
+	static persistent_ptr<leaf>
+	make(tagged_node_ptr parent, std::piecewise_construct_t,
+	     std::tuple<Args1...> &first_args,
+	     std::tuple<Args2...> &second_args, detail::index_sequence<I1...>,
+	     detail::index_sequence<I2...>);
 
 	tagged_node_ptr parent = nullptr;
 };
@@ -1298,7 +1298,8 @@ radix_tree<Key, Value, BytesView>::try_emplace(const key_type &k,
 {
 	return internal_emplace(k, [&](tagged_node_ptr parent) {
 		size_++;
-		return leaf::make(parent, k, std::forward<Args>(args)...);
+		return leaf::make_key_args(parent, k,
+					   std::forward<Args>(args)...);
 	});
 }
 
@@ -1493,8 +1494,8 @@ radix_tree<Key, Value, BytesView>::try_emplace(key_type &&k, Args &&... args)
 {
 	return internal_emplace(k, [&](tagged_node_ptr parent) {
 		size_++;
-		return leaf::make(parent, std::move(k),
-				  std::forward<Args>(args)...);
+		return leaf::make_key_args(parent, std::move(k),
+					   std::forward<Args>(args)...);
 	});
 }
 
@@ -1542,8 +1543,8 @@ radix_tree<Key, Value, BytesView>::try_emplace(K &&k, Args &&... args) ->
 {
 	return internal_emplace(k, [&](tagged_node_ptr parent) {
 		size_++;
-		return leaf::make(parent, std::forward<K>(k),
-				  std::forward<Args>(args)...);
+		return leaf::make_key_args(parent, std::forward<K>(k),
+					   std::forward<Args>(args)...);
 	});
 }
 
@@ -2805,8 +2806,8 @@ radix_tree<Key, Value, BytesView>::radix_tree_iterator<IsConst>::assign_val(
 		auto old_leaf = leaf_;
 
 		transaction::run(pop, [&] {
-			*slot = leaf::make(old_leaf->parent, old_leaf->key(),
-					   rhs);
+			*slot = leaf::make_key_args(old_leaf->parent,
+						    old_leaf->key(), rhs);
 			delete_persistent<typename radix_tree::leaf>(old_leaf);
 		});
 
@@ -2979,18 +2980,6 @@ radix_tree<Key, Value, BytesView>::find_leaf(
 	std::abort();
 }
 
-template <typename Key, typename Value, typename BytesView>
-template <typename... Args>
-persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent,
-					      Args &&... args)
-{
-	auto ptr = make_internal(std::forward<Args>(args)...);
-	ptr->parent = parent;
-
-	return ptr;
-}
-
 template <typename Key, typename Value, typename BytesView>
 Key &
 radix_tree<Key, Value, BytesView>::leaf::key()
@@ -3036,94 +3025,111 @@ radix_tree<Key, Value, BytesView>::leaf::~leaf()
 
 template <typename Key, typename Value, typename BytesView>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal()
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent)
 {
 	auto t = std::make_tuple();
-	return make_internal(std::piecewise_construct, t, t,
-			     typename detail::make_index_sequence<>::type{},
-			     typename detail::make_index_sequence<>::type{});
+	return make(parent, std::piecewise_construct, t, t,
+		    typename detail::make_index_sequence<>::type{},
+		    typename detail::make_index_sequence<>::type{});
 }
 
 template <typename Key, typename Value, typename BytesView>
 template <typename... Args1, typename... Args2>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal(
-	std::piecewise_construct_t pc, std::tuple<Args1...> first_args,
-	std::tuple<Args2...> second_args)
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent,
+					      std::piecewise_construct_t pc,
+					      std::tuple<Args1...> first_args,
+					      std::tuple<Args2...> second_args)
 {
-	return make_internal(
-		pc, first_args, second_args,
-		typename detail::make_index_sequence<Args1...>::type{},
-		typename detail::make_index_sequence<Args2...>::type{});
+	return make(parent, pc, first_args, second_args,
+		    typename detail::make_index_sequence<Args1...>::type{},
+		    typename detail::make_index_sequence<Args2...>::type{});
 }
 
 template <typename Key, typename Value, typename BytesView>
-template <typename K, typename V>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal(K &&k, V &&v)
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent,
+					      const Key &k, const Value &v)
 {
-	return make_internal(std::piecewise_construct,
-			     std::forward_as_tuple(std::forward<K>(k)),
-			     std::forward_as_tuple(std::forward<V>(v)));
+	return make(parent, std::piecewise_construct, std::forward_as_tuple(k),
+		    std::forward_as_tuple(v));
 }
 
 template <typename Key, typename Value, typename BytesView>
 template <typename K, typename V>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal(const K &k, const V &v)
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent, K &&k,
+					      V &&v)
 {
-	return make_internal(std::piecewise_construct, std::forward_as_tuple(k),
-			     std::forward_as_tuple(v));
+	return make(parent, std::piecewise_construct,
+		    std::forward_as_tuple(std::forward<K>(k)),
+		    std::forward_as_tuple(std::forward<V>(v)));
+}
+
+template <typename Key, typename Value, typename BytesView>
+template <typename K, typename... Args>
+persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
+radix_tree<Key, Value, BytesView>::leaf::make_key_args(tagged_node_ptr parent,
+						       K &&k, Args &&... args)
+{
+	return make(parent, std::piecewise_construct,
+		    std::forward_as_tuple(std::forward<K>(k)),
+		    std::forward_as_tuple(std::forward<Args>(args)...));
 }
 
 template <typename Key, typename Value, typename BytesView>
 template <typename K, typename V>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal(detail::pair<K, V> &&p)
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent,
+					      detail::pair<K, V> &&p)
 {
-	return make_internal(std::piecewise_construct,
-			     std::forward_as_tuple(std::move(p.first)),
-			     std::forward_as_tuple(std::move(p.second)));
+	return make(parent, std::piecewise_construct,
+		    std::forward_as_tuple(std::move(p.first)),
+		    std::forward_as_tuple(std::move(p.second)));
 }
 
 template <typename Key, typename Value, typename BytesView>
 template <typename K, typename V>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal(
-	const detail::pair<K, V> &p)
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent,
+					      const detail::pair<K, V> &p)
 {
-	return make_internal(std::piecewise_construct,
-			     std::forward_as_tuple(p.first),
-			     std::forward_as_tuple(p.second));
+	return make(parent, std::piecewise_construct,
+		    std::forward_as_tuple(p.first),
+		    std::forward_as_tuple(p.second));
 }
 
 template <typename Key, typename Value, typename BytesView>
 template <typename K, typename V>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal(std::pair<K, V> &&p)
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent,
+					      std::pair<K, V> &&p)
 {
-	return make_internal(std::piecewise_construct,
-			     std::forward_as_tuple(std::move(p.first)),
-			     std::forward_as_tuple(std::move(p.second)));
+	return make(parent, std::piecewise_construct,
+		    std::forward_as_tuple(std::move(p.first)),
+		    std::forward_as_tuple(std::move(p.second)));
 }
 
 template <typename Key, typename Value, typename BytesView>
 template <typename K, typename V>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal(const std::pair<K, V> &p)
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent,
+					      const std::pair<K, V> &p)
 {
-	return make_internal(std::piecewise_construct,
-			     std::forward_as_tuple(p.first),
-			     std::forward_as_tuple(p.second));
+	return make(parent, std::piecewise_construct,
+		    std::forward_as_tuple(p.first),
+		    std::forward_as_tuple(p.second));
 }
 
 template <typename Key, typename Value, typename BytesView>
 template <typename... Args1, typename... Args2, size_t... I1, size_t... I2>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal(
-	std::piecewise_construct_t, std::tuple<Args1...> &first_args,
-	std::tuple<Args2...> &second_args, detail::index_sequence<I1...>,
-	detail::index_sequence<I2...>)
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent,
+					      std::piecewise_construct_t,
+					      std::tuple<Args1...> &first_args,
+					      std::tuple<Args2...> &second_args,
+					      detail::index_sequence<I1...>,
+					      detail::index_sequence<I2...>)
 {
 	standard_alloc_policy<void> a;
 	auto key_size = total_sizeof<Key>::value(std::get<I1>(first_args)...);
@@ -3140,14 +3146,17 @@ radix_tree<Key, Value, BytesView>::leaf::make_internal(
 	new (key_dst) Key(std::forward<Args1>(std::get<I1>(first_args))...);
 	new (val_dst) Value(std::forward<Args2>(std::get<I2>(second_args))...);
 
+	ptr->parent = parent;
+
 	return ptr;
 }
 
 template <typename Key, typename Value, typename BytesView>
 persistent_ptr<typename radix_tree<Key, Value, BytesView>::leaf>
-radix_tree<Key, Value, BytesView>::leaf::make_internal(const leaf &other)
+radix_tree<Key, Value, BytesView>::leaf::make(tagged_node_ptr parent,
+					      const leaf &other)
 {
-	return make_internal(other.key(), other.value());
+	return make(parent, other.key(), other.value());
 }
 
 /**
@@ -3196,6 +3205,21 @@ swap(radix_tree<Key, Value, BytesView> &lhs,
 
 namespace detail
 {
+/* Check if type is pmem::obj::basic_string or
+ * pmem::obj::basic_inline_string */
+template <typename>
+struct is_string : std::false_type {
+};
+
+template <typename CharT, typename Traits>
+struct is_string<obj::basic_string<CharT, Traits>> : std::true_type {
+};
+
+template <typename CharT, typename Traits>
+struct is_string<obj::experimental::basic_inline_string<CharT, Traits>>
+    : std::true_type {
+};
+
 template <typename T>
 struct bytes_view<T, typename std::enable_if<is_string<T>::value>::type> {
 	using CharT = typename T::value_type;