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