feedc0de/boost_unordered
1
0
Fork 0
forked from boostorg/unordered
Code Pull Requests 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
template <typename NodePointer, typename Value> struct iterator;
template <typename ConstNodePointer, typename NodePointer,
typename Value> struct c_iterator;
template <typename NodePointer, typename Value, typename Policy>
struct l_iterator;
template <typename ConstNodePointer, typename NodePointer,
typename Value, typename Policy> struct cl_iterator;
template <typename Node> struct iterator;
template <typename Node, typename ConstNodePointer> struct c_iterator;
template <typename Node, typename Policy> struct l_iterator;
template <typename Node, typename ConstNodePointer, typename Policy>
struct cl_iterator;
// Local Iterators
//
// all no throw
template <typename NodePointer, typename Value, typename Policy>
template <typename Node, typename Policy>
struct l_iterator
: public boost::iterator<
std::forward_iterator_tag, Value, std::ptrdiff_t,
NodePointer, Value&>
std::forward_iterator_tag,
typename Node::value_type,
std::ptrdiff_t,
typename Node::node_pointer,
typename Node::value_type&>
{
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
template <typename ConstNodePointer, typename NodePointer2,
typename Value2, typename Policy2>
template <typename Node2, typename ConstNodePointer, typename Policy2>
friend struct boost::unordered::iterator_detail::cl_iterator;
private:
#endif
typedef NodePointer node_pointer;
typedef boost::unordered::iterator_detail::iterator<NodePointer, Value>
iterator;
typedef typename Node::node_pointer node_pointer;
typedef boost::unordered::iterator_detail::iterator<Node> iterator;
node_pointer ptr_;
std::size_t bucket_;
std::size_t bucket_count_;
public:
typedef typename Node::value_type value_type;
l_iterator() : ptr_() {}
l_iterator(iterator x, std::size_t b, std::size_t c)
: ptr_(x.node_), bucket_(b), bucket_count_(c) {}
Value& operator*() const {
value_type& operator*() const {
return ptr_->value();
}
Value* operator->() const {
value_type* operator->() const {
return ptr_->value_ptr();
}
@ -106,42 +107,44 @@ namespace boost { namespace unordered { namespace iterator_detail {
}
};
template <typename ConstNodePointer, typename NodePointer, typename Value,
typename Policy>
template <typename Node, typename ConstNodePointer, typename Policy>
struct cl_iterator
: public boost::iterator<
std::forward_iterator_tag, Value, std::ptrdiff_t,
ConstNodePointer, Value const&>
std::forward_iterator_tag,
typename Node::value_type,
std::ptrdiff_t,
ConstNodePointer,
typename Node::value_type const&>
{
friend struct boost::unordered::iterator_detail::l_iterator
<NodePointer, Value, Policy>;
<Node, Policy>;
private:
typedef NodePointer node_pointer;
typedef boost::unordered::iterator_detail::iterator<NodePointer, Value>
iterator;
typedef typename Node::node_pointer node_pointer;
typedef boost::unordered::iterator_detail::iterator<Node> iterator;
node_pointer ptr_;
std::size_t bucket_;
std::size_t bucket_count_;
public:
typedef typename Node::value_type value_type;
cl_iterator() : ptr_() {}
cl_iterator(iterator x, std::size_t b, std::size_t c) :
ptr_(x.node_), bucket_(b), bucket_count_(c) {}
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_)
{}
Value const&
operator*() const {
value_type const& operator*() const {
return ptr_->value();
}
Value const* operator->() const {
value_type const* operator->() const {
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
: public boost::iterator<
std::forward_iterator_tag, Value, std::ptrdiff_t,
NodePointer, Value&>
std::forward_iterator_tag,
typename Node::value_type,
std::ptrdiff_t,
typename Node::node_pointer,
typename Node::value_type&>
{
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
template <typename, typename, typename>
template <typename, typename>
friend struct boost::unordered::iterator_detail::c_iterator;
template <typename, typename, typename>
template <typename, typename>
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;
template <typename>
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;
private:
#endif
typedef NodePointer node_pointer;
typedef typename Node::node_pointer node_pointer;
node_pointer node_;
public:
typedef typename Node::value_type value_type;
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();
}
Value* operator->() const {
value_type* operator->() const {
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
: public boost::iterator<
std::forward_iterator_tag, Value, std::ptrdiff_t,
ConstNodePointer, Value const&>
std::forward_iterator_tag,
typename Node::value_type,
std::ptrdiff_t,
ConstNodePointer,
typename Node::value_type const&>
{
friend struct boost::unordered::iterator_detail::iterator<
NodePointer, Value>;
friend struct boost::unordered::iterator_detail::iterator<Node>;
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
template <typename>
@ -245,26 +256,26 @@ namespace boost { namespace unordered { namespace iterator_detail {
private:
#endif
typedef NodePointer node_pointer;
typedef boost::unordered::iterator_detail::iterator<NodePointer, Value>
iterator;
typedef typename Node::node_pointer node_pointer;
typedef boost::unordered::iterator_detail::iterator<Node> iterator;
node_pointer node_;
public:
typedef typename Node::value_type value_type;
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<
NodePointer, Value> const& x) : node_(x.node_) {}
c_iterator(iterator const& x) : node_(x.node_) {}
Value const& operator*() const {
value_type const& operator*() const {
return node_->value();
}
Value const* operator->() const {
value_type const* operator->() const {
return &node_->value();
}
@ -398,7 +409,7 @@ namespace boost { namespace unordered { namespace detail {
node_allocator_traits::construct(alloc_,
boost::addressof(*node_), node());
node_->init(static_cast<typename node::link_pointer>(node_));
node_->init(node_);
node_constructed_ = true;
}
else {
@ -432,8 +443,7 @@ namespace boost { namespace unordered { namespace detail {
typedef typename node_allocator_traits::pointer node_pointer;
typedef typename node::value_type value_type;
typedef typename node::link_pointer link_pointer;
typedef boost::unordered::iterator_detail::
iterator<node_pointer, value_type> iterator;
typedef boost::unordered::iterator_detail::iterator<node> iterator;
node_pointer nodes_;
@ -484,7 +494,7 @@ namespace boost { namespace unordered { namespace detail {
assign_impl(v);
node_pointer p = nodes_;
nodes_ = static_cast<node_pointer>(p->next_);
p->init(static_cast<typename node::link_pointer>(p));
p->init(p);
p->next_ = link_pointer();
return p;
}
@ -500,7 +510,7 @@ namespace boost { namespace unordered { namespace detail {
move_assign_impl(v);
node_pointer p = nodes_;
nodes_ = static_cast<node_pointer>(p->next_);
p->init(static_cast<typename node::link_pointer>(p));
p->init(p);
p->next_ = link_pointer();
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>
{
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 group_prev_;
node_pointer group_prev_;
std::size_t hash_;
grouped_node() :
@ -37,7 +40,7 @@ namespace boost { namespace unordered { namespace detail {
hash_(0)
{}
void init(link_pointer self)
void init(node_pointer self)
{
group_prev_ = self;
}
@ -52,9 +55,10 @@ namespace boost { namespace unordered { namespace detail {
boost::unordered::detail::ptr_bucket
{
typedef boost::unordered::detail::ptr_bucket bucket_base;
typedef grouped_ptr_node<T>* node_pointer;
typedef ptr_bucket* link_pointer;
link_pointer group_prev_;
node_pointer group_prev_;
std::size_t hash_;
grouped_ptr_node() :
@ -63,7 +67,7 @@ namespace boost { namespace unordered { namespace detail {
hash_(0)
{}
void init(link_pointer self)
void init(node_pointer self)
{
group_prev_ = self;
}
@ -254,8 +258,7 @@ namespace boost { namespace unordered { namespace detail {
return iterator();
}
n = iterator(static_cast<node_pointer>(
static_cast<node_pointer>(n.node_->group_prev_)->next_));
n = iterator(n.node_->group_prev_->next_);
}
}
@ -267,7 +270,7 @@ namespace boost { namespace unordered { namespace detail {
std::size_t x = 0;
node_pointer it = n.node_;
do {
it = static_cast<node_pointer>(it->group_prev_);
it = it->group_prev_;
++x;
} while(it != n.node_);
@ -279,10 +282,7 @@ namespace boost { namespace unordered { namespace detail {
{
iterator n = this->find_node(k);
return std::make_pair(
n, n.node_ ? iterator(
static_cast<node_pointer>(
static_cast<node_pointer>(n.node_->group_prev_)->next_
)) : n);
n, n.node_ ? iterator(n.node_->group_prev_->next_) : n);
}
// Equality
@ -295,10 +295,8 @@ namespace boost { namespace unordered { namespace detail {
{
iterator n2 = other.find_matching_node(n1);
if (!n2.node_) return false;
iterator end1(static_cast<node_pointer>(
static_cast<node_pointer>(n1.node_->group_prev_)->next_));
iterator end2(static_cast<node_pointer>(
static_cast<node_pointer>(n2.node_->group_prev_)->next_));
iterator end1(n1.node_->group_prev_->next_);
iterator end2(n2.node_->group_prev_->next_);
if (!group_equals(n1, end1, n2, end2)) return false;
n1 = end1;
}
@ -394,9 +392,9 @@ namespace boost { namespace unordered { namespace detail {
node_pointer n,
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_;
static_cast<node_pointer>(pos->group_prev_)->next_ = n;
pos->group_prev_->next_ = 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_);
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);
this->fix_bucket(bucket_index, prev);
@ -609,8 +607,7 @@ namespace boost { namespace unordered { namespace detail {
// Delete the nodes.
do {
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);
bucket_index = this->fix_bucket(bucket_index, prev);
} 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)
{
node_pointer prev = static_cast<node_pointer>(begin->group_prev_);
node_pointer prev = begin->group_prev_;
if (prev->next_ != begin) prev = node_pointer();
if (end) {
node_pointer first = end;
while (first != begin && static_cast<node_pointer>(first->group_prev_)->next_ == first) {
first = static_cast<node_pointer>(first->group_prev_);
while (first != begin && first->group_prev_->next_ == first) {
first = first->group_prev_;
}
boost::swap(first->group_prev_, end->group_prev_);
@ -635,8 +632,8 @@ namespace boost { namespace unordered { namespace detail {
if (prev) {
node_pointer first = prev;
while (static_cast<node_pointer>(first->group_prev_)->next_ == first) {
first = static_cast<node_pointer>(first->group_prev_);
while (first->group_prev_->next_ == first) {
first = first->group_prev_;
}
boost::swap(first->group_prev_, begin->group_prev_);
}
@ -655,10 +652,7 @@ namespace boost { namespace unordered { namespace detail {
while (n.node_) {
std::size_t key_hash = n.node_->hash_;
iterator group_end(
static_cast<node_pointer>(
static_cast<node_pointer>(n.node_->group_prev_)->next_
));
iterator group_end(n.node_->group_prev_->next_);
node_pointer first_node = creator.create(*n);
node_pointer end = first_node;
@ -687,8 +681,7 @@ namespace boost { namespace unordered { namespace detail {
link_pointer prev = this->get_previous_start();
while (prev->next_)
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.
@ -700,7 +693,7 @@ namespace boost { namespace unordered { namespace detail {
dst.bucket_count_, end->hash_));
if (!b->next_) {
b->next_ = static_cast<node_pointer>(prev);
b->next_ = prev;
return end;
}
else {

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

@ -168,14 +168,13 @@ namespace boost { namespace unordered { namespace detail {
node_constructor;
typedef boost::unordered::iterator_detail::
iterator<node_pointer, value_type> iterator;
iterator<node> iterator;
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::
l_iterator<node_pointer, value_type, policy> l_iterator;
l_iterator<node, policy> l_iterator;
typedef boost::unordered::iterator_detail::
cl_iterator<const_node_pointer, node_pointer, value_type, policy>
cl_iterator;
cl_iterator<node, const_node_pointer, policy> cl_iterator;
////////////////////////////////////////////////////////////////////////
// Members
@ -236,16 +235,14 @@ namespace boost { namespace unordered { namespace detail {
iterator begin() const
{
return size_ ? iterator(static_cast<node_pointer>(
get_previous_start()->next_)) : iterator();
return size_ ? iterator(get_previous_start()->next_) : iterator();
}
iterator begin(std::size_t bucket_index) const
{
if (!size_) return iterator();
link_pointer prev = get_previous_start(bucket_index);
return prev ? iterator(static_cast<node_pointer>(prev->next_)) :
iterator();
return prev ? iterator(prev->next_) : iterator();
}
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>
{
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_;
std::size_t hash_;
@ -37,7 +38,7 @@ namespace boost { namespace unordered { namespace detail {
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
{
typedef boost::unordered::detail::ptr_bucket bucket_base;
typedef ptr_node<T>* node_pointer;
typedef ptr_bucket* link_pointer;
std::size_t hash_;
@ -60,7 +62,7 @@ namespace boost { namespace unordered { namespace detail {
hash_(0)
{}
void init(link_pointer)
void init(node_pointer)
{
}