feedc0de/boost_unordered
1
0
Fork 0
forked from boostorg/unordered
Code Pull Requests Activity

Update node set to conditionally use strong vs weak typedef

Browse Source
This commit is contained in:
Christian Mazakas
2023-01-10 12:36:27 -08:00
parent ff956ad080
commit 7d1e64a3c6
1 changed files with 68 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
include/boost/unordered/unordered_node_set.hpp
View File

@ -39,30 +39,15 @@ namespace boost {
using init_type = Key; using init_type = Key;
using value_type = Key; using value_type = Key;
// struct element_type static Key const& extract(value_type const& key) { return key; }
// {
// value_type* p;
// };
// static value_type& value_from(element_type x) { return *x.p; }
#if 1
using element_type = value_type*; using element_type = value_type*;
static value_type& value_from(element_type x) { return *x; } static value_type& value_from(element_type x) { return *x; }
static Key const& extract(value_type const& key) { return key; }
// static Key const& extract(element_type k) { return *k.p; }
// static element_type&& move(element_type& x) { return std::move(x); }
static Key const& extract(element_type k) { return *k; } static Key const& extract(element_type k) { return *k; }
static element_type&& move(element_type& x) { return std::move(x); } static element_type&& move(element_type& x) { return std::move(x); }
// template <class A>
// static void construct(A&, element_type* p, element_type&& x)
// {
// p->p = x.p;
// x.p = nullptr;
// }
template <class A> template <class A>
static void construct(A&, element_type* p, element_type&& x) static void construct(A&, element_type* p, element_type&& x)
{ {
@ -70,35 +55,20 @@ namespace boost {
x = nullptr; x = nullptr;
} }
// template <class A> template <class A, class... Args>
// static void construct(A& al, element_type* p, element_type const& copy) static void construct(A& al, element_type* p, element_type const& x)
// { {
// p->p = boost::to_address(boost::allocator_allocate(al, 1)); *p = boost::to_address(boost::allocator_allocate(al, 1));
// try { try {
// boost::allocator_construct(al, p->p, *copy.p); boost::allocator_construct(al, *p, *x);
// } catch (...) { } catch (...) {
// boost::allocator_deallocate(al, boost::allocator_deallocate(al,
// boost::pointer_traits< boost::pointer_traits<
// typename boost::allocator_pointer<A>::type>::pointer_to(*p->p), typename boost::allocator_pointer<A>::type>::pointer_to(**p),
// 1); 1);
// throw; throw;
// } }
// } }
// template <class A, class... Args>
// static void construct(A& al, element_type* p, Args&&... args)
// {
// p->p = boost::to_address(boost::allocator_allocate(al, 1));
// try {
// boost::allocator_construct(al, p->p, std::forward<Args>(args)...);
// } catch (...) {
// boost::allocator_deallocate(al,
// boost::pointer_traits<
// typename boost::allocator_pointer<A>::type>::pointer_to(*p->p),
// 1);
// throw;
// }
// }
template <class A, class... Args> template <class A, class... Args>
static void construct(A& al, element_type* p, Args&&... args) static void construct(A& al, element_type* p, Args&&... args)
@ -115,20 +85,9 @@ namespace boost {
} }
} }
// template <class A> static void destroy(A& al, element_type* p) noexcept
// {
// if (p->p) {
// boost::allocator_destroy(al, p->p);
// boost::allocator_deallocate(al,
// boost::pointer_traits<
// typename boost::allocator_pointer<A>::type>::pointer_to(*p->p),
// 1);
// }
// }
template <class A> static void destroy(A& al, element_type* p) noexcept template <class A> static void destroy(A& al, element_type* p) noexcept
{ {
if (p) { if (*p) {
boost::allocator_destroy(al, *p); boost::allocator_destroy(al, *p);
boost::allocator_deallocate(al, boost::allocator_deallocate(al,
boost::pointer_traits< boost::pointer_traits<
@ -136,13 +95,63 @@ namespace boost {
1); 1);
} }
} }
#else
struct element_type
{
value_type* p;
};
static value_type& value_from(element_type x) { return *x.p; }
static Key const& extract(element_type k) { return *k.p; }
static element_type&& move(element_type& x) { return std::move(x); }
template <class A>
static void construct(A& al, element_type* p, element_type const& copy)
{
construct(al, p, *copy.p);
}
template <typename Allocator>
static void construct(
Allocator&, element_type* p, element_type&& x) noexcept
{
p->p = x.p;
x.p = nullptr;
}
template <class A, class... Args>
static void construct(A& al, element_type* p, Args&&... args)
{
p->p = boost::to_address(boost::allocator_allocate(al, 1));
try {
boost::allocator_construct(al, p->p, std::forward<Args>(args)...);
} catch (...) {
boost::allocator_deallocate(al,
boost::pointer_traits<
typename boost::allocator_pointer<A>::type>::pointer_to(*p->p),
1);
throw;
}
}
template <class A> static void destroy(A& al, element_type* p) noexcept
{
if (p->p) {
boost::allocator_destroy(al, p->p);
boost::allocator_deallocate(al,
boost::pointer_traits<
typename boost::allocator_pointer<A>::type>::pointer_to(*p->p),
1);
}
}
#endif
}; };
} // namespace detail } // namespace detail
template <class Key, class Hash, class KeyEqual, class Allocator> template <class Key, class Hash, class KeyEqual, class Allocator>
class unordered_node_set class unordered_node_set
{ {
using set_types = detail::flat_set_types<Key>; using set_types = detail::node_set_types<Key>;
using table_type = detail::foa::table<set_types, Hash, KeyEqual, using table_type = detail::foa::table<set_types, Hash, KeyEqual,
typename boost::allocator_rebind<Allocator, typename boost::allocator_rebind<Allocator,