SCORE_LIB_STATE_EXPORT bool operator==( const TreeNode<State::ExprData>& lhs, const TreeNode<State::ExprData>& rhs) { const auto& ltd = static_cast<const State::ExprData&>(lhs); const auto& rtd = static_cast<const State::ExprData&>(rhs); bool b = (ltd == rtd) && (lhs.m_children.size() == rhs.m_children.size()); if (!b) return false; auto l = lhs.begin(); auto e = lhs.end(); auto r = rhs.begin(); while (l != e) { if (*l != *r) return false; ++l; ++r; } return true; }
void PreRootVisitor::__run__ (const TreeNode &node) { process(node); TreeNode::ChildrenIterator it = node.begin (); while(it != node.end()) { __run__(*it); it ++; } }
iterator insert(StoredObject&& toStore) { TreeNode* node = getNode(toStore.location); if (node->level() > 0) { // We store one element at time so there will be a moment before node overflow when its // count will be equal capacity. Then we'll relocate all its elements to the new child // nodes. At worst scenario, all elements will be relocated to the same node, so its // count() will be again equal to capacity. The loop ends when at least one element is // relocated to the another child node. while (node->count() == nodeCapacity && node->level() > 0) { typename TreeNode::iterator it; typename TreeNode::iterator itEnd = node->end(); for (it = node->begin(); it != itEnd; ++it) { node->child(it->location).insert(std::move(*it)); } node->clear(); node = &(node->child(toStore.location)); } } return iterator(node, node->insert(std::move(toStore))); }