forked from boostorg/intrusive
346 lines
12 KiB
C++
346 lines
12 KiB
C++
/////////////////////////////////////////////////////////////////////////////
|
||
//
|
||
// (C) Copyright Daniel Steck 2021
|
||
//
|
||
// Distributed under the Boost Software License, Version 1.0.
|
||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||
// http://www.boost.org/LICENSE_1_0.txt)
|
||
//
|
||
// See http://www.boost.org/libs/intrusive for documentation.
|
||
//
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
#include <boost/intrusive/rbtree.hpp>
|
||
#include <boost/next_prior.hpp>
|
||
|
||
#include <cassert>
|
||
#include <vector>
|
||
|
||
namespace {
|
||
|
||
struct Node : boost::intrusive::set_base_hook<> {};
|
||
|
||
typedef boost::intrusive::rbtree<Node> Tree;
|
||
typedef typename Tree::node_traits NodeTraits;
|
||
|
||
NodeTraits::node_ptr get_parent(const Node& node) {
|
||
return NodeTraits::get_parent(node.this_ptr());
|
||
}
|
||
|
||
NodeTraits::node_ptr get_left(const Node& node) {
|
||
return NodeTraits::get_left(node.this_ptr());
|
||
}
|
||
|
||
NodeTraits::node_ptr get_right(const Node& node) {
|
||
return NodeTraits::get_right(node.this_ptr());
|
||
}
|
||
|
||
Tree perfect_binary_tree_of_height_2(std::vector<Node>& node_buffer) {
|
||
// Perfect binary tree of height 2
|
||
// 3
|
||
// ╱ ╲
|
||
// 1 5
|
||
// ╱ ╲ ╱ ╲
|
||
// 0 2 4 6
|
||
assert(node_buffer.size() == 7);
|
||
Tree tree;
|
||
|
||
const Tree::iterator it3 = tree.insert_before(tree.end(), node_buffer[3]);
|
||
const Tree::iterator it1 = tree.insert_before(it3, node_buffer[1]);
|
||
const Tree::iterator it5 = tree.insert_before(tree.end(), node_buffer[5]);
|
||
tree.insert_before(it1, node_buffer[0]);
|
||
tree.insert_before(it3, node_buffer[2]);
|
||
tree.insert_before(it5, node_buffer[4]);
|
||
tree.insert_before(tree.end(), node_buffer[6]);
|
||
|
||
// Make sure we got the tree we expected
|
||
assert(get_parent(node_buffer[0]) == node_buffer[1].this_ptr());
|
||
assert(get_left(node_buffer[0]) == NULL);
|
||
assert(get_right(node_buffer[0]) == NULL);
|
||
assert(get_parent(node_buffer[1]) == node_buffer[3].this_ptr());
|
||
assert(get_left(node_buffer[1]) == node_buffer[0].this_ptr());
|
||
assert(get_right(node_buffer[1]) == node_buffer[2].this_ptr());
|
||
assert(get_parent(node_buffer[2]) == node_buffer[1].this_ptr());
|
||
assert(get_left(node_buffer[2]) == NULL);
|
||
assert(get_right(node_buffer[2]) == NULL);
|
||
assert(get_left(node_buffer[3]) == node_buffer[1].this_ptr());
|
||
assert(get_right(node_buffer[3]) == node_buffer[5].this_ptr());
|
||
assert(get_parent(node_buffer[4]) == node_buffer[5].this_ptr());
|
||
assert(get_left(node_buffer[4]) == NULL);
|
||
assert(get_right(node_buffer[4]) == NULL);
|
||
assert(get_parent(node_buffer[5]) == node_buffer[3].this_ptr());
|
||
assert(get_left(node_buffer[5]) == node_buffer[4].this_ptr());
|
||
assert(get_right(node_buffer[5]) == node_buffer[6].this_ptr());
|
||
assert(get_parent(node_buffer[6]) == node_buffer[5].this_ptr());
|
||
assert(get_left(node_buffer[6]) == NULL);
|
||
assert(get_right(node_buffer[6]) == NULL);
|
||
|
||
return tree;
|
||
}
|
||
|
||
// Test that swaps node_buffer 0 and 4 and verifies the results
|
||
struct SwapUnrelatedLeafNodesTest {
|
||
std::vector<Node>& node_buffer;
|
||
Tree& tree;
|
||
|
||
SwapUnrelatedLeafNodesTest(std::vector<Node>& node_buffer, Tree& tree)
|
||
: node_buffer(node_buffer), tree(tree) {}
|
||
|
||
void check() {
|
||
assert(&*boost::next(tree.begin(), 0) == &node_buffer[4]);
|
||
assert(&*boost::next(tree.begin(), 1) == &node_buffer[1]);
|
||
assert(&*boost::next(tree.begin(), 2) == &node_buffer[2]);
|
||
assert(&*boost::next(tree.begin(), 3) == &node_buffer[3]);
|
||
assert(&*boost::next(tree.begin(), 4) == &node_buffer[0]);
|
||
assert(&*boost::next(tree.begin(), 5) == &node_buffer[5]);
|
||
assert(&*boost::next(tree.begin(), 6) == &node_buffer[6]);
|
||
assert(get_parent(node_buffer[0]) == node_buffer[5].this_ptr());
|
||
assert(get_left(node_buffer[0]) == NULL);
|
||
assert(get_right(node_buffer[0]) == NULL);
|
||
assert(get_left(node_buffer[1]) == node_buffer[4].this_ptr());
|
||
assert(get_right(node_buffer[1]) == node_buffer[2].this_ptr());
|
||
assert(get_parent(node_buffer[4]) == node_buffer[1].this_ptr());
|
||
assert(get_left(node_buffer[4]) == NULL);
|
||
assert(get_right(node_buffer[4]) == NULL);
|
||
assert(get_left(node_buffer[5]) == node_buffer[0].this_ptr());
|
||
assert(get_right(node_buffer[5]) == node_buffer[6].this_ptr());
|
||
}
|
||
|
||
void swap04() {
|
||
node_buffer[0].swap_nodes(node_buffer[4]);
|
||
}
|
||
|
||
void swap40() {
|
||
node_buffer[4].swap_nodes(node_buffer[0]);
|
||
}
|
||
};
|
||
|
||
// Test that swaps node_buffer 0 and 2 and verifies the results
|
||
struct SwapSiblingLeafNodesTest {
|
||
std::vector<Node>& node_buffer;
|
||
Tree& tree;
|
||
|
||
SwapSiblingLeafNodesTest(std::vector<Node>& node_buffer, Tree& tree)
|
||
: node_buffer(node_buffer), tree(tree) {}
|
||
|
||
void check() {
|
||
assert(&*boost::next(tree.begin(), 0) == &node_buffer[2]);
|
||
assert(&*boost::next(tree.begin(), 1) == &node_buffer[1]);
|
||
assert(&*boost::next(tree.begin(), 2) == &node_buffer[0]);
|
||
assert(&*boost::next(tree.begin(), 3) == &node_buffer[3]);
|
||
assert(&*boost::next(tree.begin(), 4) == &node_buffer[4]);
|
||
assert(&*boost::next(tree.begin(), 5) == &node_buffer[5]);
|
||
assert(&*boost::next(tree.begin(), 6) == &node_buffer[6]);
|
||
assert(get_parent(node_buffer[0]) == node_buffer[1].this_ptr());
|
||
assert(get_left(node_buffer[0]) == NULL);
|
||
assert(get_right(node_buffer[0]) == NULL);
|
||
assert(get_left(node_buffer[1]) == node_buffer[2].this_ptr());
|
||
assert(get_right(node_buffer[1]) == node_buffer[0].this_ptr());
|
||
assert(get_parent(node_buffer[2]) == node_buffer[1].this_ptr());
|
||
assert(get_left(node_buffer[2]) == NULL);
|
||
assert(get_right(node_buffer[2]) == NULL);
|
||
}
|
||
|
||
void swap02() {
|
||
node_buffer[0].swap_nodes(node_buffer[2]);
|
||
}
|
||
|
||
void swap20() {
|
||
node_buffer[2].swap_nodes(node_buffer[0]);
|
||
}
|
||
};
|
||
|
||
// Test that swaps node_buffer 1 and 5 and verifies the results
|
||
struct SwapSiblingNodesTest {
|
||
std::vector<Node>& node_buffer;
|
||
Tree& tree;
|
||
|
||
SwapSiblingNodesTest(std::vector<Node>& node_buffer, Tree& tree)
|
||
: node_buffer(node_buffer), tree(tree) {}
|
||
|
||
void check() {
|
||
assert(&*boost::next(tree.begin(), 0) == &node_buffer[0]);
|
||
assert(&*boost::next(tree.begin(), 1) == &node_buffer[5]);
|
||
assert(&*boost::next(tree.begin(), 2) == &node_buffer[2]);
|
||
assert(&*boost::next(tree.begin(), 3) == &node_buffer[3]);
|
||
assert(&*boost::next(tree.begin(), 4) == &node_buffer[4]);
|
||
assert(&*boost::next(tree.begin(), 5) == &node_buffer[1]);
|
||
assert(&*boost::next(tree.begin(), 6) == &node_buffer[6]);
|
||
assert(get_parent(node_buffer[0]) == node_buffer[5].this_ptr());
|
||
assert(get_parent(node_buffer[1]) == node_buffer[3].this_ptr());
|
||
assert(get_left(node_buffer[1]) == node_buffer[4].this_ptr());
|
||
assert(get_right(node_buffer[1]) == node_buffer[6].this_ptr());
|
||
assert(get_parent(node_buffer[2]) == node_buffer[5].this_ptr());
|
||
assert(get_left(node_buffer[3]) == node_buffer[5].this_ptr());
|
||
assert(get_right(node_buffer[3]) == node_buffer[1].this_ptr());
|
||
assert(get_parent(node_buffer[4]) == node_buffer[1].this_ptr());
|
||
assert(get_parent(node_buffer[5]) == node_buffer[3].this_ptr());
|
||
assert(get_left(node_buffer[5]) == node_buffer[0].this_ptr());
|
||
assert(get_right(node_buffer[5]) == node_buffer[2].this_ptr());
|
||
assert(get_parent(node_buffer[6]) == node_buffer[1].this_ptr());
|
||
}
|
||
|
||
void swap15() {
|
||
node_buffer[1].swap_nodes(node_buffer[5]);
|
||
}
|
||
|
||
void swap51() {
|
||
node_buffer[5].swap_nodes(node_buffer[1]);
|
||
}
|
||
};
|
||
|
||
// Test that swaps node_buffer 0 and 1 and verifies the results
|
||
struct SwapWithLeftChildTest {
|
||
std::vector<Node>& node_buffer;
|
||
Tree& tree;
|
||
|
||
SwapWithLeftChildTest(std::vector<Node>& node_buffer, Tree& tree)
|
||
: node_buffer(node_buffer), tree(tree) {}
|
||
|
||
void check() {
|
||
assert(&*boost::next(tree.begin(), 0) == &node_buffer[1]);
|
||
assert(&*boost::next(tree.begin(), 1) == &node_buffer[0]);
|
||
assert(&*boost::next(tree.begin(), 2) == &node_buffer[2]);
|
||
assert(&*boost::next(tree.begin(), 3) == &node_buffer[3]);
|
||
assert(&*boost::next(tree.begin(), 4) == &node_buffer[4]);
|
||
assert(&*boost::next(tree.begin(), 5) == &node_buffer[5]);
|
||
assert(&*boost::next(tree.begin(), 6) == &node_buffer[6]);
|
||
assert(get_parent(node_buffer[0]) == node_buffer[3].this_ptr());
|
||
assert(get_left(node_buffer[0]) == node_buffer[1].this_ptr());
|
||
assert(get_right(node_buffer[0]) == node_buffer[2].this_ptr());
|
||
assert(get_parent(node_buffer[1]) == node_buffer[0].this_ptr());
|
||
assert(get_left(node_buffer[1]) == NULL);
|
||
assert(get_right(node_buffer[1]) == NULL);
|
||
assert(get_parent(node_buffer[2]) == node_buffer[0].this_ptr());
|
||
assert(get_left(node_buffer[2]) == NULL);
|
||
assert(get_right(node_buffer[2]) == NULL);
|
||
}
|
||
|
||
void swap01() {
|
||
node_buffer[0].swap_nodes(node_buffer[1]);
|
||
}
|
||
|
||
void swap10() {
|
||
node_buffer[1].swap_nodes(node_buffer[0]);
|
||
}
|
||
};
|
||
|
||
// Test that swaps node_buffer 1 and 2 and verifies the results
|
||
struct SwapWithRightChildTest {
|
||
std::vector<Node>& node_buffer;
|
||
Tree& tree;
|
||
|
||
SwapWithRightChildTest(std::vector<Node>& node_buffer, Tree& tree)
|
||
: node_buffer(node_buffer), tree(tree) {}
|
||
|
||
void check() {
|
||
assert(&*boost::next(tree.begin(), 0) == &node_buffer[0]);
|
||
assert(&*boost::next(tree.begin(), 1) == &node_buffer[2]);
|
||
assert(&*boost::next(tree.begin(), 2) == &node_buffer[1]);
|
||
assert(&*boost::next(tree.begin(), 3) == &node_buffer[3]);
|
||
assert(&*boost::next(tree.begin(), 4) == &node_buffer[4]);
|
||
assert(&*boost::next(tree.begin(), 5) == &node_buffer[5]);
|
||
assert(&*boost::next(tree.begin(), 6) == &node_buffer[6]);
|
||
assert(get_parent(node_buffer[0]) == node_buffer[2].this_ptr());
|
||
assert(get_left(node_buffer[0]) == NULL);
|
||
assert(get_right(node_buffer[0]) == NULL);
|
||
assert(get_parent(node_buffer[1]) == node_buffer[2].this_ptr());
|
||
assert(get_left(node_buffer[1]) == NULL);
|
||
assert(get_right(node_buffer[1]) == NULL);
|
||
assert(get_parent(node_buffer[2]) == node_buffer[3].this_ptr());
|
||
assert(get_left(node_buffer[2]) == node_buffer[0].this_ptr());
|
||
assert(get_right(node_buffer[2]) == node_buffer[1].this_ptr());
|
||
}
|
||
|
||
void swap12() {
|
||
node_buffer[1].swap_nodes(node_buffer[2]);
|
||
}
|
||
|
||
void swap21() {
|
||
node_buffer[2].swap_nodes(node_buffer[1]);
|
||
}
|
||
};
|
||
|
||
}
|
||
|
||
int main() {
|
||
{ // SwapUnrelatedLeafNodesTest 0 -> 4
|
||
std::vector<Node> node_buffer(7);
|
||
Tree tree = perfect_binary_tree_of_height_2(node_buffer);
|
||
SwapUnrelatedLeafNodesTest test(node_buffer, tree);
|
||
test.swap04();
|
||
test.check();
|
||
}
|
||
|
||
{ // SwapUnrelatedLeafNodesTest 0 <- 4
|
||
std::vector<Node> node_buffer(7);
|
||
Tree tree = perfect_binary_tree_of_height_2(node_buffer);
|
||
SwapUnrelatedLeafNodesTest test(node_buffer, tree);
|
||
test.swap40();
|
||
test.check();
|
||
}
|
||
|
||
{ // SwapSiblingLeafNodesTest 0 -> 2
|
||
std::vector<Node> node_buffer(7);
|
||
Tree tree = perfect_binary_tree_of_height_2(node_buffer);
|
||
SwapSiblingLeafNodesTest test(node_buffer, tree);
|
||
test.swap02();
|
||
test.check();
|
||
}
|
||
|
||
{ // SwapSiblingLeafNodesTest 0 <- 2
|
||
std::vector<Node> node_buffer(7);
|
||
Tree tree = perfect_binary_tree_of_height_2(node_buffer);
|
||
SwapSiblingLeafNodesTest test(node_buffer, tree);
|
||
test.swap20();
|
||
test.check();
|
||
}
|
||
|
||
{ // SwapSiblingNodesTest 1 -> 5
|
||
std::vector<Node> node_buffer(7);
|
||
Tree tree = perfect_binary_tree_of_height_2(node_buffer);
|
||
SwapSiblingNodesTest test(node_buffer, tree);
|
||
test.swap15();
|
||
test.check();
|
||
}
|
||
|
||
{ // SwapSiblingNodesTest 1 <- 5
|
||
std::vector<Node> node_buffer(7);
|
||
Tree tree = perfect_binary_tree_of_height_2(node_buffer);
|
||
SwapSiblingNodesTest test(node_buffer, tree);
|
||
test.swap51();
|
||
test.check();
|
||
}
|
||
|
||
{ // SwapWithLeftChildTest 0 -> 1
|
||
std::vector<Node> node_buffer(7);
|
||
Tree tree = perfect_binary_tree_of_height_2(node_buffer);
|
||
SwapWithLeftChildTest test(node_buffer, tree);
|
||
test.swap01();
|
||
test.check();
|
||
}
|
||
|
||
{ // SwapWithLeftChildTest 0 <- 1
|
||
std::vector<Node> node_buffer(7);
|
||
Tree tree = perfect_binary_tree_of_height_2(node_buffer);
|
||
SwapWithLeftChildTest test(node_buffer, tree);
|
||
test.swap10();
|
||
test.check();
|
||
}
|
||
|
||
{ // SwapWithRightChildTest 1 -> 2
|
||
std::vector<Node> node_buffer(7);
|
||
Tree tree = perfect_binary_tree_of_height_2(node_buffer);
|
||
SwapWithRightChildTest test(node_buffer, tree);
|
||
test.swap12();
|
||
test.check();
|
||
}
|
||
|
||
{ // SwapWithRightChildTest 1 <- 2
|
||
std::vector<Node> node_buffer(7);
|
||
Tree tree = perfect_binary_tree_of_height_2(node_buffer);
|
||
SwapWithRightChildTest test(node_buffer, tree);
|
||
test.swap21();
|
||
test.check();
|
||
}
|
||
}
|