QuadNode<T, lev>& nextNode(QuadNode<T, lev>& node)
{
if (node.hasChildren())
{
if (node.childExists(0, 0)) return node.child(0, 0);
else if (node.childExists(0, 1)) return node.child(0, 1);
else if (node.childExists(1, 0)) return node.child(1, 0);
else return node.child(1, 1);
}
else
{
QuadNode<T, lev>* refNode = &node;
// initial prepare for the first check of parent node
bool x = refNode->locationCode().x[refNode->level()];
bool y = refNode->locationCode().y[refNode->level()];
while (*refNode != refNode->parent())
{
refNode = &(refNode->parent());
// evaluate node number in node->parent() child list and check only children with
// higher index.
for (uint32_t i = QuadNode<T, lev>::locToInt(x, y) + 1; i < 4; ++i)
{
bool cx = (i & 2) >> 1;
bool cy = i & 1;
if (refNode->childExists(cx, cy))
{
return refNode->child(cx, cy);
}
}
// prepare the next (parent) node to check
x = refNode->locationCode().x[refNode->level()];
y = refNode->locationCode().y[refNode->level()];
}
// At this point refNode == refNode.parent(), so it's a header. We'll return it as
// nextNode() of the last (rightmost) node in a tree.
return *refNode;
}
}
QuadNode<T, lev>& previousNode(QuadNode<T, lev>& node)
{
// If header node is given, then its previousNode is the rightmost one.
// requirement: --end()
if (node.parent() == node)
return node.rightMostNode();
QuadNode<T, lev>* refNode = &node;
bool x = refNode->locationCode().x[refNode->level()];
bool y = refNode->locationCode().y[refNode->level()];
refNode = &(refNode->parent());
for (int i = QuadNode<T, lev>::locToInt(x, y) - 1; i >= 0; --i)
{
bool cx = (i & 2) >> 1;
bool cy = i & 1;
if (refNode->childExists(cx, cy))
{
refNode = &(refNode->child(cx, cy));
while (refNode->hasChildren())
{
if (refNode->childExists(1, 1)) refNode = &(refNode->child(1, 1));
else if (refNode->childExists(1, 0)) refNode = &(refNode->child(1, 0));
else if (refNode->childExists(0, 1)) refNode = &(refNode->child(0, 1));
else refNode = &(refNode->child(0, 0));
}
return *refNode;
}
}
// If no previous sibling has been found, this will actually return node.parent()
// The special case is root: its previousNode is header node and previousNode(header) is
// rightmost node. It's some kind of circular buffer and we'll let iterators handle this case to
// avoid it (e.g by setting (--begin())::node to nullptr)
return *refNode;
}
