void N::deleteChildren(N *node) {
if (N::isLeaf(node)) {
return;
}
switch (node->getType()) {
case NTypes::N4: {
auto n = static_cast<N4 *>(node);
n->deleteChildren();
return;
}
case NTypes::N16: {
auto n = static_cast<N16 *>(node);
n->deleteChildren();
return;
}
case NTypes::N48: {
auto n = static_cast<N48 *>(node);
n->deleteChildren();
return;
}
case NTypes::N256: {
auto n = static_cast<N256 *>(node);
n->deleteChildren();
return;
}
}
assert(false);
__builtin_unreachable();
}
NodeBase::~NodeBase()
{
deleteChildren();
if (next != 0)
next->previous = previous;
if (previous != 0)
previous->next = next;
if (parent != 0)
{
if (parent->firstChild == this)
parent->firstChild = next;
if (parent->lastChild == this)
parent->lastChild = previous;
}
// Delete outgoing edges.
// TODO: Renders ingoing edges invalid. Assume or assert that all nodes on the same level are deleted?
for (NodeBase::edge_iterator outEdgeIt(begin_outEdge());
outEdgeIt != end_outEdge(); ++outEdgeIt)
{
delete *outEdgeIt;
}
--s_nodeCount;
DEBUG_EXEC(
if (s_nodeCount == 0)
std::cout << "Deleted all tree nodes!" << std::endl;
);
Json&Json::operator=(JsonConst jsonConst)
{
deleteChildren();
switch (jsonConst) {
case JsonConst::EmptyObject:
mType = JsonType::Object;
entries = new Map<Json>();
break;
case JsonConst::EmptyArray:
mType = JsonType::Array;
elements = new std::vector<Json>();
break;
case JsonConst::TRUE:
mType = JsonType::Boolean;
boolean = true;
break;
case JsonConst::FALSE:
mType = JsonType::Boolean;
boolean = false;
break;
case JsonConst::Null:
mType = JsonType::Null;
break;
}
return *this;
}
Json& Json::operator=(Json&& other)
{
deleteChildren();
memcpy(this, &other, sizeof(Json));
memset(&other, 0, sizeof(Json));
return *this;
}
void sLinsysRoot::sync()
{
//delete children
deleteChildren();
//assert(false);
//delete local stuff
if( nxupp + nxlow > 0 ) {
delete dd;
delete dq;
}
delete nomegaInv;
delete rhs;
if (solver) delete solver;
if (kkt) delete kkt;
//allocate
// if( nxupp + nxlow > 0 ) {
//dd = OoqpVectorHandle(stochNode->newPrimalVector());
//dq = OoqpVectorHandle(stochNode->newPrimalVector());
dd = stochNode->newPrimalVector();
dq = stochNode->newPrimalVector();
data->getDiagonalOfQ( *dq );
// }
nomegaInv = stochNode->newDualZVector();
rhs = stochNode->newRhs();
data->getLocalSizes(locnx, locmy, locmz);
createChildren(data);
kkt = createKKT(data);
solver = createSolver(data, kkt);
}
void deleteChildren(QTreeWidgetItem *item)
{
while(item->childCount() > 0)
{
QTreeWidgetItem *child = item->takeChild(0);
deleteChildren(child);
delete child;
}
}
void StashFileSystem::deleteChildren(StashNodeData nodeData)
{
if (nodeData.children != nullptr) {
Q_FOREACH (auto data, nodeData.children->values()) {
deleteChildren(data);
}
delete nodeData.children;
nodeData.children = nullptr;
}
TwObject::~TwObject()
{
if (m_guardPtr->hasPtr())
{
m_guardPtr->clearGuardObject( this);
}
delete m_guardPtr;
m_guardPtr = nullptr;
deleteChildren();
setParent(nullptr);
}
void CExecPN::pop()
{
if( m_cmd != NULL )
{
//cout << m_id << " " ;
// execute the command
m_cmd -> Exec( this ) ;
// delete decendents
deleteChildren();
//cout << " **-> " << g_byte_cnt << endl;
}
}
// ------------------------------------------------------------------------------------------------------------------------------
bool Node::InitEmptyChildren(unsigned int numChildren) {
if (numChildren == 0) {
LOG_WARNING << "Initialize an empty children array with 0 elements";
return false;
}
deleteChildren();
NumChildren = numChildren;
Children.resize(NumChildren);
LOG_DEBUG << "Create an empty children! " << "NumChildren: " << NumChildren;
return true;
}
bool MorphTarget::loadFromFile(const QString &filename)
{
QFile file(filename);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
return false;
QFileInfo fileInfo(filename);
BasicTokenizer tokenizer(&file);
if (!_load(tokenizer)) {
deleteChildren();
file.close();
qDebug() << "Invalid file";
return false;
}
QFileInfo info(filename);
setName(info.baseName());
file.close();
return true;
}
// Reimplemented
void QmvItem::setOpen( bool b )
{
// State consistent already
if ( b == open )
return;
open = b;
// Add the children
if ( open ) {
createChildren();
initChildren();
} else {
deleteChildren();
}
qApp->processEvents();
listview->updateEditorSize();
}
void Variable::setChildValues(const QVariantMap& data)
{
deleteChildren();
QMapIterator<QString, QVariant> i(data);
while (i.hasNext()) {
i.next();
kDebug() << i.key() << i.value();
KDevelop::Variable* xvar = currentSession()->variableController()->
createVariable(model(), this,
i.key());
Variable* var = static_cast<Variable*>(xvar);
var->setTopLevel(false);
appendChild(var);
if (i.value().canConvert(QVariant::Map)) {
var->setCrossfireValue(i.value().toMap());
} else {
var->setValue(i.value().toString());
}
}
}
void intersectTrees(Node* root, char* p, Node* root2, char* p2)
{
while(true)
{
if(p == root->last && p2 == root2->last)
{
// intersect all possible subtrees
int i;
for(i=0; i<26; i++)
if(root->suffix[i] != NULL && root2->suffix[i] != NULL)
intersectTrees(root->suffix[i], root->suffix[i]->first, root2->suffix[i], root2->suffix[i]->first);
else if(root->suffix[i] != NULL) // only tree 1 has child nodes -> we don't need them any more
{
deleteNode(root->suffix[i]);
root->suffix[i] = NULL;
}
return;
}
else if(p == root->last) // move down in the first tree if possible
{
// we can forget about all other branches
Node* child = root->suffix[*p2-97];
root->suffix[*p2-97] = NULL;
deleteChildrenExcept(root, child);
if(child == NULL)
return;
if(root->parent != NULL) // merge this lonely node with its only child node
{
int strlen = root->last - root->first;
// prepend string of this node
child->first -= strlen;
// relink children
root->parent->suffix[*(child->first)-97] = child;
child->parent = root->parent;
// finally get rid of this node
deleteNode(root);
}
root = child;
p = root->first;
}
else if (p2 == root2->last) // move down in the second tree if possible
{
if(root2->suffix[*p-97] == NULL)
{
// no further going down in tree 2 -> also forget about child nodes of tree 1
deleteChildren(root);
root->last = p;
return;
}
root2 = root2->suffix[*p-97];
p2 = root2->first;
}
else if(*p != *p2) // end of branch matching
{
deleteChildren(root);
root->last = p;
return;
}
else // match strings of local nodes
{
p++;
p2++;
}
}
}
/*!
*/
InnerNode::~InnerNode()
{
deleteChildren();
removeFromRelated();
}
FileTreeItem::~FileTreeItem()
{
deleteChildren();
}
void FastXmlDocument::unload() {
if(loaded) {
while(children.size()>0) deleteChildren();
loaded = false;
}
}
Json::~Json()
{
deleteChildren();
}
SceneNode::~SceneNode() {
deleteChildren();
SceneManager::instance()->delNode(this);
}
StashFileSystem::~StashFileSystem()
{
deleteChildren(root);
}
