boostorg/unordered
1
0
Fork 1
mirror of https://github.com/boostorg/unordered.git synced 2025-07-30 19:37:14 +02:00
Code Issues Packages Projects Releases Wiki Activity

Unordered: Clean up the pointer silliness.

Browse Source 
[SVN r81208]
This commit is contained in:
Daniel James
2012-11-05 18:33:15 +00:00
parent ccc3d1c83d
commit d495cbd7e6
4 changed files with 105 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
include/boost/unordered/detail/buckets.hpp
View File

@ -37,49 +37,50 @@ namespace boost { namespace unordered { namespace iterator_detail {
// //
// all no throw // all no throw
template <typename NodePointer, typename Value> struct iterator; template <typename Node> struct iterator;
template <typename ConstNodePointer, typename NodePointer, template <typename Node, typename ConstNodePointer> struct c_iterator;
typename Value> struct c_iterator; template <typename Node, typename Policy> struct l_iterator;
template <typename NodePointer, typename Value, typename Policy> template <typename Node, typename ConstNodePointer, typename Policy>
struct l_iterator; struct cl_iterator;
template <typename ConstNodePointer, typename NodePointer,
typename Value, typename Policy> struct cl_iterator;
// Local Iterators // Local Iterators
// //
// all no throw // all no throw
template <typename NodePointer, typename Value, typename Policy> template <typename Node, typename Policy>
struct l_iterator struct l_iterator
: public boost::iterator< : public boost::iterator<
std::forward_iterator_tag, Value, std::ptrdiff_t, std::forward_iterator_tag,
NodePointer, Value&> typename Node::value_type,
std::ptrdiff_t,
typename Node::node_pointer,
typename Node::value_type&>
{ {
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
template <typename ConstNodePointer, typename NodePointer2, template <typename Node2, typename ConstNodePointer, typename Policy2>
typename Value2, typename Policy2>
friend struct boost::unordered::iterator_detail::cl_iterator; friend struct boost::unordered::iterator_detail::cl_iterator;
private: private:
#endif #endif
typedef NodePointer node_pointer; typedef typename Node::node_pointer node_pointer;
typedef boost::unordered::iterator_detail::iterator<NodePointer, Value> typedef boost::unordered::iterator_detail::iterator<Node> iterator;
iterator;
node_pointer ptr_; node_pointer ptr_;
std::size_t bucket_; std::size_t bucket_;
std::size_t bucket_count_; std::size_t bucket_count_;
public: public:
typedef typename Node::value_type value_type;
l_iterator() : ptr_() {} l_iterator() : ptr_() {}
l_iterator(iterator x, std::size_t b, std::size_t c) l_iterator(iterator x, std::size_t b, std::size_t c)
: ptr_(x.node_), bucket_(b), bucket_count_(c) {} : ptr_(x.node_), bucket_(b), bucket_count_(c) {}
Value& operator*() const { value_type& operator*() const {
return ptr_->value(); return ptr_->value();
} }
Value* operator->() const { value_type* operator->() const {
return ptr_->value_ptr(); return ptr_->value_ptr();
} }
@ -106,42 +107,44 @@ namespace boost { namespace unordered { namespace iterator_detail {
} }
}; };
template <typename ConstNodePointer, typename NodePointer, typename Value, template <typename Node, typename ConstNodePointer, typename Policy>
typename Policy>
struct cl_iterator struct cl_iterator
: public boost::iterator< : public boost::iterator<
std::forward_iterator_tag, Value, std::ptrdiff_t, std::forward_iterator_tag,
ConstNodePointer, Value const&> typename Node::value_type,
std::ptrdiff_t,
ConstNodePointer,
typename Node::value_type const&>
{ {
friend struct boost::unordered::iterator_detail::l_iterator friend struct boost::unordered::iterator_detail::l_iterator
<NodePointer, Value, Policy>; <Node, Policy>;
private: private:
typedef NodePointer node_pointer; typedef typename Node::node_pointer node_pointer;
typedef boost::unordered::iterator_detail::iterator<NodePointer, Value> typedef boost::unordered::iterator_detail::iterator<Node> iterator;
iterator;
node_pointer ptr_; node_pointer ptr_;
std::size_t bucket_; std::size_t bucket_;
std::size_t bucket_count_; std::size_t bucket_count_;
public: public:
typedef typename Node::value_type value_type;
cl_iterator() : ptr_() {} cl_iterator() : ptr_() {}
cl_iterator(iterator x, std::size_t b, std::size_t c) : cl_iterator(iterator x, std::size_t b, std::size_t c) :
ptr_(x.node_), bucket_(b), bucket_count_(c) {} ptr_(x.node_), bucket_(b), bucket_count_(c) {}
cl_iterator(boost::unordered::iterator_detail::l_iterator< cl_iterator(boost::unordered::iterator_detail::l_iterator<
NodePointer, Value, Policy> const& x) : Node, Policy> const& x) :
ptr_(x.ptr_), bucket_(x.bucket_), bucket_count_(x.bucket_count_) ptr_(x.ptr_), bucket_(x.bucket_), bucket_count_(x.bucket_count_)
{} {}
Value const& value_type const& operator*() const {
operator*() const {
return ptr_->value(); return ptr_->value();
} }
Value const* operator->() const { value_type const* operator->() const {
return ptr_->value_ptr(); return ptr_->value_ptr();
} }
@ -168,18 +171,21 @@ namespace boost { namespace unordered { namespace iterator_detail {
} }
}; };
template <typename NodePointer, typename Value> template <typename Node>
struct iterator struct iterator
: public boost::iterator< : public boost::iterator<
std::forward_iterator_tag, Value, std::ptrdiff_t, std::forward_iterator_tag,
NodePointer, Value&> typename Node::value_type,
std::ptrdiff_t,
typename Node::node_pointer,
typename Node::value_type&>
{ {
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
template <typename, typename, typename> template <typename, typename>
friend struct boost::unordered::iterator_detail::c_iterator; friend struct boost::unordered::iterator_detail::c_iterator;
template <typename, typename, typename> template <typename, typename>
friend struct boost::unordered::iterator_detail::l_iterator; friend struct boost::unordered::iterator_detail::l_iterator;
template <typename, typename, typename, typename> template <typename, typename, typename>
friend struct boost::unordered::iterator_detail::cl_iterator; friend struct boost::unordered::iterator_detail::cl_iterator;
template <typename> template <typename>
friend struct boost::unordered::detail::table; friend struct boost::unordered::detail::table;
@ -189,20 +195,23 @@ namespace boost { namespace unordered { namespace iterator_detail {
friend struct boost::unordered::detail::grouped_table_impl; friend struct boost::unordered::detail::grouped_table_impl;
private: private:
#endif #endif
typedef NodePointer node_pointer; typedef typename Node::node_pointer node_pointer;
node_pointer node_; node_pointer node_;
public: public:
typedef typename Node::value_type value_type;
iterator() : node_() {} iterator() : node_() {}
explicit iterator(node_pointer const& x) : node_(x) {} explicit iterator(typename Node::link_pointer x) :
node_(static_cast<node_pointer>(x)) {}
Value& operator*() const { value_type& operator*() const {
return node_->value(); return node_->value();
} }
Value* operator->() const { value_type* operator->() const {
return &node_->value(); return &node_->value();
} }
@ -226,14 +235,16 @@ namespace boost { namespace unordered { namespace iterator_detail {
} }
}; };
template <typename ConstNodePointer, typename NodePointer, typename Value> template <typename Node, typename ConstNodePointer>
struct c_iterator struct c_iterator
: public boost::iterator< : public boost::iterator<
std::forward_iterator_tag, Value, std::ptrdiff_t, std::forward_iterator_tag,
ConstNodePointer, Value const&> typename Node::value_type,
std::ptrdiff_t,
ConstNodePointer,
typename Node::value_type const&>
{ {
friend struct boost::unordered::iterator_detail::iterator< friend struct boost::unordered::iterator_detail::iterator<Node>;
NodePointer, Value>;
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
template <typename> template <typename>
@ -245,26 +256,26 @@ namespace boost { namespace unordered { namespace iterator_detail {
private: private:
#endif #endif
typedef typename Node::node_pointer node_pointer;
typedef NodePointer node_pointer; typedef boost::unordered::iterator_detail::iterator<Node> iterator;
typedef boost::unordered::iterator_detail::iterator<NodePointer, Value>
iterator;
node_pointer node_; node_pointer node_;
public: public:
typedef typename Node::value_type value_type;
c_iterator() : node_() {} c_iterator() : node_() {}
explicit c_iterator(node_pointer const& x) : node_(x) {} explicit c_iterator(typename Node::link_pointer x) :
node_(static_cast<node_pointer>(x)) {}
c_iterator(boost::unordered::iterator_detail::iterator< c_iterator(iterator const& x) : node_(x.node_) {}
NodePointer, Value> const& x) : node_(x.node_) {}
Value const& operator*() const { value_type const& operator*() const {
return node_->value(); return node_->value();
} }
Value const* operator->() const { value_type const* operator->() const {
return &node_->value(); return &node_->value();
} }
@ -398,7 +409,7 @@ namespace boost { namespace unordered { namespace detail {
node_allocator_traits::construct(alloc_, node_allocator_traits::construct(alloc_,
boost::addressof(*node_), node()); boost::addressof(*node_), node());
node_->init(static_cast<typename node::link_pointer>(node_)); node_->init(node_);
node_constructed_ = true; node_constructed_ = true;
} }
else { else {
@ -432,8 +443,7 @@ namespace boost { namespace unordered { namespace detail {
typedef typename node_allocator_traits::pointer node_pointer; typedef typename node_allocator_traits::pointer node_pointer;
typedef typename node::value_type value_type; typedef typename node::value_type value_type;
typedef typename node::link_pointer link_pointer; typedef typename node::link_pointer link_pointer;
typedef boost::unordered::iterator_detail:: typedef boost::unordered::iterator_detail::iterator<node> iterator;
iterator<node_pointer, value_type> iterator;
node_pointer nodes_; node_pointer nodes_;
@ -484,7 +494,7 @@ namespace boost { namespace unordered { namespace detail {
assign_impl(v); assign_impl(v);
node_pointer p = nodes_; node_pointer p = nodes_;
nodes_ = static_cast<node_pointer>(p->next_); nodes_ = static_cast<node_pointer>(p->next_);
p->init(static_cast<typename node::link_pointer>(p)); p->init(p);
p->next_ = link_pointer(); p->next_ = link_pointer();
return p; return p;
} }
@ -500,7 +510,7 @@ namespace boost { namespace unordered { namespace detail {
move_assign_impl(v); move_assign_impl(v);
node_pointer p = nodes_; node_pointer p = nodes_;
nodes_ = static_cast<node_pointer>(p->next_); nodes_ = static_cast<node_pointer>(p->next_);
p->init(static_cast<typename node::link_pointer>(p)); p->init(p);
p->next_ = link_pointer(); p->next_ = link_pointer();
return p; return p;
} }

59
include/boost/unordered/detail/equivalent.hpp
View File

@ -25,10 +25,13 @@ namespace boost { namespace unordered { namespace detail {
boost::unordered::detail::value_base<T> boost::unordered::detail::value_base<T>
{ {
typedef typename ::boost::unordered::detail::rebind_wrap< typedef typename ::boost::unordered::detail::rebind_wrap<
A, grouped_node<A, T> >::type::pointer link_pointer; A, grouped_node<A, T> >::type allocator;
typedef typename ::boost::unordered::detail::
allocator_traits<allocator>::pointer node_pointer;
typedef node_pointer link_pointer;
link_pointer next_; link_pointer next_;
link_pointer group_prev_; node_pointer group_prev_;
std::size_t hash_; std::size_t hash_;
grouped_node() : grouped_node() :
@ -37,7 +40,7 @@ namespace boost { namespace unordered { namespace detail {
hash_(0) hash_(0)
{} {}
void init(link_pointer self) void init(node_pointer self)
{ {
group_prev_ = self; group_prev_ = self;
} }
@ -52,9 +55,10 @@ namespace boost { namespace unordered { namespace detail {
boost::unordered::detail::ptr_bucket boost::unordered::detail::ptr_bucket
{ {
typedef boost::unordered::detail::ptr_bucket bucket_base; typedef boost::unordered::detail::ptr_bucket bucket_base;
typedef grouped_ptr_node<T>* node_pointer;
typedef ptr_bucket* link_pointer; typedef ptr_bucket* link_pointer;
link_pointer group_prev_; node_pointer group_prev_;
std::size_t hash_; std::size_t hash_;
grouped_ptr_node() : grouped_ptr_node() :
@ -63,7 +67,7 @@ namespace boost { namespace unordered { namespace detail {
hash_(0) hash_(0)
{} {}
void init(link_pointer self) void init(node_pointer self)
{ {
group_prev_ = self; group_prev_ = self;
} }
@ -254,8 +258,7 @@ namespace boost { namespace unordered { namespace detail {
return iterator(); return iterator();
} }
n = iterator(static_cast<node_pointer>( n = iterator(n.node_->group_prev_->next_);
static_cast<node_pointer>(n.node_->group_prev_)->next_));
} }
} }
@ -267,7 +270,7 @@ namespace boost { namespace unordered { namespace detail {
std::size_t x = 0; std::size_t x = 0;
node_pointer it = n.node_; node_pointer it = n.node_;
do { do {
it = static_cast<node_pointer>(it->group_prev_); it = it->group_prev_;
++x; ++x;
} while(it != n.node_); } while(it != n.node_);
@ -279,10 +282,7 @@ namespace boost { namespace unordered { namespace detail {
{ {
iterator n = this->find_node(k); iterator n = this->find_node(k);
return std::make_pair( return std::make_pair(
n, n.node_ ? iterator( n, n.node_ ? iterator(n.node_->group_prev_->next_) : n);
static_cast<node_pointer>(
static_cast<node_pointer>(n.node_->group_prev_)->next_
)) : n);
} }
// Equality // Equality
@ -295,10 +295,8 @@ namespace boost { namespace unordered { namespace detail {
{ {
iterator n2 = other.find_matching_node(n1); iterator n2 = other.find_matching_node(n1);
if (!n2.node_) return false; if (!n2.node_) return false;
iterator end1(static_cast<node_pointer>( iterator end1(n1.node_->group_prev_->next_);
static_cast<node_pointer>(n1.node_->group_prev_)->next_)); iterator end2(n2.node_->group_prev_->next_);
iterator end2(static_cast<node_pointer>(
static_cast<node_pointer>(n2.node_->group_prev_)->next_));
if (!group_equals(n1, end1, n2, end2)) return false; if (!group_equals(n1, end1, n2, end2)) return false;
n1 = end1; n1 = end1;
} }
@ -394,9 +392,9 @@ namespace boost { namespace unordered { namespace detail {
node_pointer n, node_pointer n,
node_pointer pos) node_pointer pos)
{ {
n->next_ = static_cast<node_pointer>(pos->group_prev_)->next_; n->next_ = pos->group_prev_->next_;
n->group_prev_ = pos->group_prev_; n->group_prev_ = pos->group_prev_;
static_cast<node_pointer>(pos->group_prev_)->next_ = n; pos->group_prev_->next_ = n;
pos->group_prev_ = n; pos->group_prev_ = n;
} }
@ -564,7 +562,7 @@ namespace boost { namespace unordered { namespace detail {
} }
node_pointer first_node = static_cast<node_pointer>(prev->next_); node_pointer first_node = static_cast<node_pointer>(prev->next_);
link_pointer end = static_cast<node_pointer>(first_node->group_prev_)->next_; link_pointer end = first_node->group_prev_->next_;
std::size_t count = this->delete_nodes(prev, end); std::size_t count = this->delete_nodes(prev, end);
this->fix_bucket(bucket_index, prev); this->fix_bucket(bucket_index, prev);
@ -609,8 +607,7 @@ namespace boost { namespace unordered { namespace detail {
// Delete the nodes. // Delete the nodes.
do { do {
link_pointer group_end = link_pointer group_end =
static_cast<node_pointer>( static_cast<node_pointer>(prev->next_)->group_prev_->next_;
static_cast<node_pointer>(prev->next_)->group_prev_)->next_;
this->delete_nodes(prev, group_end); this->delete_nodes(prev, group_end);
bucket_index = this->fix_bucket(bucket_index, prev); bucket_index = this->fix_bucket(bucket_index, prev);
} while(prev->next_ != end); } while(prev->next_ != end);
@ -620,13 +617,13 @@ namespace boost { namespace unordered { namespace detail {
static link_pointer split_groups(node_pointer begin, node_pointer end) static link_pointer split_groups(node_pointer begin, node_pointer end)
{ {
node_pointer prev = static_cast<node_pointer>(begin->group_prev_); node_pointer prev = begin->group_prev_;
if (prev->next_ != begin) prev = node_pointer(); if (prev->next_ != begin) prev = node_pointer();
if (end) { if (end) {
node_pointer first = end; node_pointer first = end;
while (first != begin && static_cast<node_pointer>(first->group_prev_)->next_ == first) { while (first != begin && first->group_prev_->next_ == first) {
first = static_cast<node_pointer>(first->group_prev_); first = first->group_prev_;
} }
boost::swap(first->group_prev_, end->group_prev_); boost::swap(first->group_prev_, end->group_prev_);
@ -635,8 +632,8 @@ namespace boost { namespace unordered { namespace detail {
if (prev) { if (prev) {
node_pointer first = prev; node_pointer first = prev;
while (static_cast<node_pointer>(first->group_prev_)->next_ == first) { while (first->group_prev_->next_ == first) {
first = static_cast<node_pointer>(first->group_prev_); first = first->group_prev_;
} }
boost::swap(first->group_prev_, begin->group_prev_); boost::swap(first->group_prev_, begin->group_prev_);
} }
@ -655,10 +652,7 @@ namespace boost { namespace unordered { namespace detail {
while (n.node_) { while (n.node_) {
std::size_t key_hash = n.node_->hash_; std::size_t key_hash = n.node_->hash_;
iterator group_end( iterator group_end(n.node_->group_prev_->next_);
static_cast<node_pointer>(
static_cast<node_pointer>(n.node_->group_prev_)->next_
));
node_pointer first_node = creator.create(*n); node_pointer first_node = creator.create(*n);
node_pointer end = first_node; node_pointer end = first_node;
@ -687,8 +681,7 @@ namespace boost { namespace unordered { namespace detail {
link_pointer prev = this->get_previous_start(); link_pointer prev = this->get_previous_start();
while (prev->next_) while (prev->next_)
prev = place_in_bucket(*this, prev, prev = place_in_bucket(*this, prev,
static_cast<node_pointer>( static_cast<node_pointer>(prev->next_)->group_prev_);
static_cast<node_pointer>(prev->next_)->group_prev_));
} }
// Iterate through the nodes placing them in the correct buckets. // Iterate through the nodes placing them in the correct buckets.
@ -700,7 +693,7 @@ namespace boost { namespace unordered { namespace detail {
dst.bucket_count_, end->hash_)); dst.bucket_count_, end->hash_));
if (!b->next_) { if (!b->next_) {
b->next_ = static_cast<node_pointer>(prev); b->next_ = prev;
return end; return end;
} }
else { else {

15
include/boost/unordered/detail/table.hpp
View File

@ -168,14 +168,13 @@ namespace boost { namespace unordered { namespace detail {
node_constructor; node_constructor;
typedef boost::unordered::iterator_detail:: typedef boost::unordered::iterator_detail::
iterator<node_pointer, value_type> iterator; iterator<node> iterator;
typedef boost::unordered::iterator_detail:: typedef boost::unordered::iterator_detail::
c_iterator<const_node_pointer, node_pointer, value_type> c_iterator; c_iterator<node, const_node_pointer> c_iterator;
typedef boost::unordered::iterator_detail:: typedef boost::unordered::iterator_detail::
l_iterator<node_pointer, value_type, policy> l_iterator; l_iterator<node, policy> l_iterator;
typedef boost::unordered::iterator_detail:: typedef boost::unordered::iterator_detail::
cl_iterator<const_node_pointer, node_pointer, value_type, policy> cl_iterator<node, const_node_pointer, policy> cl_iterator;
cl_iterator;
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// Members // Members
@ -236,16 +235,14 @@ namespace boost { namespace unordered { namespace detail {
iterator begin() const iterator begin() const
{ {
return size_ ? iterator(static_cast<node_pointer>( return size_ ? iterator(get_previous_start()->next_) : iterator();
get_previous_start()->next_)) : iterator();
} }
iterator begin(std::size_t bucket_index) const iterator begin(std::size_t bucket_index) const
{ {
if (!size_) return iterator(); if (!size_) return iterator();
link_pointer prev = get_previous_start(bucket_index); link_pointer prev = get_previous_start(bucket_index);
return prev ? iterator(static_cast<node_pointer>(prev->next_)) : return prev ? iterator(prev->next_) : iterator();
iterator();
} }
float load_factor() const float load_factor() const

8
include/boost/unordered/detail/unique.hpp
View File

@ -27,7 +27,8 @@ namespace boost { namespace unordered { namespace detail {
boost::unordered::detail::value_base<T> boost::unordered::detail::value_base<T>
{ {
typedef typename ::boost::unordered::detail::rebind_wrap< typedef typename ::boost::unordered::detail::rebind_wrap<
A, unique_node<A, T> >::type::pointer link_pointer; A, unique_node<A, T> >::type::pointer node_pointer;
typedef node_pointer link_pointer;
link_pointer next_; link_pointer next_;
std::size_t hash_; std::size_t hash_;
@ -37,7 +38,7 @@ namespace boost { namespace unordered { namespace detail {
hash_(0) hash_(0)
{} {}
void init(link_pointer) void init(node_pointer)
{ {
} }
@ -51,6 +52,7 @@ namespace boost { namespace unordered { namespace detail {
boost::unordered::detail::ptr_bucket boost::unordered::detail::ptr_bucket
{ {
typedef boost::unordered::detail::ptr_bucket bucket_base; typedef boost::unordered::detail::ptr_bucket bucket_base;
typedef ptr_node<T>* node_pointer;
typedef ptr_bucket* link_pointer; typedef ptr_bucket* link_pointer;
std::size_t hash_; std::size_t hash_;
@ -60,7 +62,7 @@ namespace boost { namespace unordered { namespace detail {
hash_(0) hash_(0)
{} {}
void init(link_pointer) void init(node_pointer)
{ {
} }