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; }
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; } }