void mt_event_destroy(mt_event e) { for (int i = 0; i < e->signals.item_cnt; i++) { HANDLE ehdl = ((HANDLE*)e->signals.buffer)[i]; if (ehdl != NULL) CloseHandle(ehdl); } arr_destroy(&e->signals); A_FREE(e->alloc, e); }
void wld_releasemgr() { for (int i = 0; i < g_wld.sections.item_cnt; i++) { struct wld_section* s = &((struct wld_section*)g_wld.sections.buffer)[i]; wld_destroy_section(s); } arr_destroy(&g_wld.sections); hashtable_open_destroy(&g_wld.stable); wld_zero(); }
void prf_releasemgr() { MT_ATOMIC_SET(g_prf.init, FALSE); mt_mutex_release(&g_prf.samples_mtx); webserver_release(); arr_destroy(&g_prf.cmds); if (g_prf.samples_front != NULL) prf_destroy_samples((struct prf_samples*)g_prf.samples_front); if (g_prf.samples_back != NULL) prf_destroy_samples((struct prf_samples*)g_prf.samples_back); prf_zero(); }
static void avl_clear_intern (avl_t avl, int free_data) { arr_t arr; avl_entry_t curr; size_t size; /* Create a new array to be used as a stack */ arr = arr_init (); /* Iterate over every node */ arr_insert_back (arr, avl->root); while ((size = arr_size (arr)) > 0) { /* Get the current element from the stack */ curr = (avl_entry_t) arr_get (arr, size-1); arr_remove (arr, size-1); /* Check for invalid nodes */ if (curr == NULL) continue; /* Push children onto the stack */ arr_insert_back (arr, curr->left); arr_insert_back (arr, curr->right); /* Free parent */ if (free_data && curr->data != NULL) free (curr->data); avl->free (curr->key); free (curr); } /* Cleanup the array */ arr_destroy (arr); /* Update AVL Struct */ avl->size = 0; avl->root = NULL; return; }
void rs_releasemgr() { struct linked_list* unload_item = g_rs.unload_items; while (unload_item != NULL) { struct linked_list* nitem = unload_item->next; FREE(unload_item->data); unload_item = nitem; } hashtable_chained_destroy(&g_rs.dict); mem_pool_destroy(&g_rs.dict_itempool); mem_pool_destroy(&g_rs.freeslot_pool); arr_destroy(&g_rs.ress); mem_pool_destroy(&g_rs.load_data_pool); if (g_rs.job_params.load_items != NULL) FREE(g_rs.job_params.load_items); if (g_rs.job_result.ptrs != NULL) FREE(g_rs.job_result.ptrs); log_print(LOG_TEXT, "res-mgr released."); }
void wld_destroy_section(struct wld_section* s) { hashtable_open_destroy(&s->vtable); arr_destroy(&s->vars); }
static avl_error_t avl_insert_intern (avl_t avl, void * key, void * data, int replace) { arr_t stack; size_t size; avl_entry_t *curr, tmp; int ret; /* Create a stack for saving the path */ stack = arr_init (); if (stack == NULL) return AVL_MALLOC_FAILED; /* Iterate down the the insertion point and update the balance */ curr = &avl->root; while (*curr != NULL) { /* Insert the node into the backlog */ arr_insert_back (stack, curr); /* Determine the correct traveral direction */ ret = avl->compare (key, (*curr)->key); if (ret == 0) { arr_destroy (stack); if (replace) { (*curr)->data = data; return AVL_OK; } else return AVL_KEY_EXISTS; } else if (ret < 0) { (*curr)->balance--; curr = &(*curr)->left; } else { (*curr)->balance++; curr = &(*curr)->right; } } /* Create the new entry */ tmp = (avl_entry_t) malloc (sizeof (struct _avl_entry_t)); if (tmp == NULL) return AVL_MALLOC_FAILED; tmp->left = NULL; tmp->right = NULL; tmp->balance = 0; tmp->key = key; tmp->data = data; /* Insert the entry */ *curr = tmp; /* Rebalance the tree upward */ while ((size = arr_size (stack)) > 0) { break; } /* Increase the Tree Size */ avl->size++; /* Destroy the path stack */ arr_destroy (stack); return AVL_OK; }