void QuadTree<DATA>::delete_branch(Tree_Node * deadNode) { if (deadNode!=NULL) { delete_branch(deadNode->North); delete_branch(deadNode->South); delete_branch(deadNode->East); delete_branch(deadNode->West); delete(deadNode->data); delete(deadNode); } }
/****************************************************************************** * Removes the registry key with all subkeys. Parses full key name. * * Parameters: * reg_key_name - full name of registry branch to delete. Ignored if is NULL, * empty, points to register key class, does not exist. */ void delete_registry_key(TCHAR* reg_key_name) { TCHAR* branch_name; DWORD branch_name_len; HKEY reg_key_class; HKEY branch_key; if (!reg_key_name || !reg_key_name[0]) { return; } /* open the specified key */ reg_key_class = getRegClass(reg_key_name); if (reg_key_class == (HKEY)ERROR_INVALID_PARAMETER) { _tprintf(_T("Incorrect registry class specification in '%s'\n"), reg_key_name); //exit(1); return; } branch_name = getRegKeyName(reg_key_name); CHECK_ENOUGH_MEMORY(branch_name); branch_name_len = _tcslen(branch_name); if (!branch_name[0]) { _tprintf(_T("Can't delete registry class '%s'\n"), reg_key_name); //exit(1); return; } if (RegOpenKey(reg_key_class, branch_name, &branch_key) == ERROR_SUCCESS) { /* check whether the key exists */ RegCloseKey(branch_key); delete_branch(reg_key_class, &branch_name, &branch_name_len); } HeapFree(GetProcessHeap(), 0, branch_name); }
void UI_delete_branch(emulator_instance& inst, uint64_t id, std::function<void(std::exception&)> onerror) { auto project = inst.project; inst.iqueue->run_async([project, id]() { auto p = project->get(); if(!p) return; p->delete_branch(id); p->flush(); }, onerror); }
bool QuadTree<DATA>::delete_branch(DATA * data) { Tree_Node * target_node=find_in_tree_helper(head,data); if (target_node==NULL) { return false; } if (head!=NULL) { delete_branch(target_node->North); delete_branch(target_node->South); delete_branch(target_node->East); delete_branch(target_node->West); target_node.North=NULL; target_node.South=NULL; target_node.East=NULL; target_node.West=NULL; } }
void force_answer_false(NODEptr as_leaf) { ASI asi = Delay(as_leaf); VariantSF subgoal; if (is_conditional_answer(as_leaf)) { subgoal = asi_subgoal(asi); release_all_dls(asi); delete_branch(as_leaf, &subg_ans_root_ptr(subgoal)); simplify_pos_unsupported(as_leaf); mark_subgoal_failed(subgoal); simplify_neg_fails(subgoal); } }
static void handle_unsupported_answer_subst(NODEptr as_leaf) { ASI unsup_asi = Delay(as_leaf); VariantSF unsup_subgoal = asi_subgoal(unsup_asi); #ifdef DEBUG_DELAYVAR fprintf(stddbg, ">>>> start handle_unsupported_answer_subst()\n"); #endif delete_branch(as_leaf, &subg_ans_root_ptr(unsup_subgoal)); simplify_pos_unsupported(as_leaf); if (is_completed(unsup_subgoal)) { if (subgoal_fails(unsup_subgoal)) { simplify_neg_fails(unsup_subgoal); } } free(unsup_asi); }
void project_state::do_branch_rm(const std::string& args) { regex_results r = regex("([0-9]+)[ \t]*", args); if(!r) { messages << "Syntax: delete-branch <id>" << std::endl; return; } try { auto prj = get(); uint64_t bid = parse_value<uint64_t>(r[1]); if(!prj) throw std::runtime_error("Not in project context"); prj->delete_branch(bid); messages << "Deleted branch #" << bid << std::endl; prj->flush(); } catch(std::exception& e) { messages << "Can't delete branch: " << e.what() << std::endl; } }
bool switch_lpm_trie_delete(switch_lpm_trie_t *trie, const char *prefix, int prefix_length) { node_t *current_node = trie->root; byte_t byte; unsigned short prefix_key; value_t *pdata = NULL; while (prefix_length >= 8) { byte = (byte_t)*prefix; node_t *node = get_next_node(current_node, byte); if (!node) return NULL; prefix++; prefix_length -= 8; current_node = node; } if (prefix_length == 0) prefix_key = 0; else prefix_key = get_prefix_key((unsigned)prefix_length, (byte_t)*prefix); pdata = get_prefix_ptr(current_node, prefix_key); if (!pdata) return false; if (trie->release_memory) { assert(delete_prefix(current_node, prefix_key) == 1); current_node->pref_num--; while (current_node->pref_num == 0 && current_node->branch_num == 0) { node_t *tmp = current_node; current_node = current_node->parent; if (!current_node) break; assert(delete_branch(current_node, tmp->child_id) == 1); switch_free(tmp); current_node->branch_num--; } } trie->num_entries--; return true; }
/****************************************************************************** * Recursive function which removes the registry key with all subkeys. */ BOOL delete_branch(HKEY key, TCHAR** reg_key_name_buf, DWORD* reg_key_name_len) { HKEY branch_key; DWORD max_sub_key_len; DWORD subkeys; DWORD curr_len; LONG ret; long int i; if (RegOpenKey(key, *reg_key_name_buf, &branch_key) != ERROR_SUCCESS) { REGPROC_print_error(); return FALSE; } /* get size information and resize the buffers if necessary */ if (RegQueryInfoKey(branch_key, NULL, NULL, NULL, &subkeys, &max_sub_key_len, NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) { REGPROC_print_error(); RegCloseKey(branch_key); return FALSE; } curr_len = _tcslen(*reg_key_name_buf); REGPROC_resize_char_buffer(reg_key_name_buf, reg_key_name_len, max_sub_key_len + curr_len + 1); (*reg_key_name_buf)[curr_len] = '\\'; for (i = subkeys - 1; i >= 0; i--) { DWORD buf_len = *reg_key_name_len - curr_len; ret = RegEnumKeyEx(branch_key, i, *reg_key_name_buf + curr_len + 1, &buf_len, NULL, NULL, NULL, NULL); if (ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA && ret != ERROR_NO_MORE_ITEMS) { REGPROC_print_error(); RegCloseKey(branch_key); return FALSE; } else { delete_branch(key, reg_key_name_buf, reg_key_name_len); } } (*reg_key_name_buf)[curr_len] = '\0'; RegCloseKey(branch_key); RegDeleteKey(key, *reg_key_name_buf); return TRUE; }
QuadTree<DATA>:: ~QuadTree() { delete_branch(head); }