static void *dmd_realloc(void *old, int size, const char *file, int line)
{
struct dmd_memblock *mb, sb;
void *p;
// debug4("realloc %s:%d (%ul -> %i)", file, line, (unsigned long) old, size);
sb.ptr = old;
mb = btree_get(&dmd_tree, &sb);
if (!mb) {
putlog(LOG_MISC, "*", "*** DMD: FAILED REALLOC %s:%d (%d). Old pointer not found. This is probably fatal!", file, line, size);
return NULL;
}
p = mb->ptr;
p = realloc(p, size);
if (!p) {
putlog(LOG_MISC, "*", "*** DMD: FAILED REALLOC %s:%d (%d). realloc() returned NULL", file, line, size);
// fatal("Memory re-allocation failed", 0);
}
if (((unsigned long) p) != ((unsigned long) old)) {
// debug0("newpointer");
btree_remove(&dmd_tree, mb);
mb = dmd_create(p, size, line, file);
btree_add(&dmd_tree, (void *) mb);
} else {
// debug0("oldpointer");
mb->size = size;
/* p = strrchr(file, '/');
strncpy(mb->file, p ? p + 1 : file, DMD_FILE_SIZE);
mb->file[DMD_FILE_SIZE] = 0;
mb->line = line;*/
}
return p;
}
int
pdb_item_destroy(pdb_t *p, uint32_t id)
{
void *item_get;
pdb_entry_t *item;
if (btree_remove(p->db, id, &item_get) == FALSE) {
debug_msg("Cannot delete item because it does not exist!\n");
return FALSE;
}
item = (pdb_entry_t*)item_get;
pdb_item_validate(item);
assert(id == item->ssrc);
/* clean up elements of item here ************************************/
if (item->render_3D_data != NULL) {
render_3D_free(&item->render_3D_data);
}
if (item->enc_fmt != NULL) {
xfree(item->enc_fmt);
item->enc_fmt = NULL;
}
/*********************************************************************/
debug_msg("Removing persistent database entry for SSRC 0x%08lx\n",
item->ssrc);
xfree(item);
p->nelem--;
return TRUE;
}
int
main()
{
btree_t *b;
uint32_t i, *x;
uint32_t v[] = {15, 5, 16, 3, 12, 20, 10, 13, 18, 23, 6, 7};
uint32_t nv = sizeof(v) / sizeof(v[0]);
btree_create(&b);
for(i = 0; i < nv; i++) {
x = (uint32_t*)xmalloc(sizeof(uint32_t));
*x = (uint32_t)random();
if (btree_add(b, v[i], (void*)x) != TRUE) {
printf("Fail Add %lu %lu\n", v[i], *x);
}
}
printf("depth %d\n", btree_depth(b->root));
btree_dump(b);
sleep(3);
btree_remove(b, 5, (void*)&x);
btree_dump(b);
sleep(3);
btree_remove(b, 16, (void*)&x);
btree_dump(b);
sleep(3);
btree_remove(b, 13, (void*)&x);
btree_dump(b);
while (btree_get_root_key(b, &i)) {
if (btree_remove(b, i, (void*)&x) == FALSE) {
fprintf(stderr, "Failed to remove %lu\n", i);
}
btree_dump(b);
sleep(1);
}
if (btree_destroy(&b) == FALSE) {
printf("Failed to destroy \n");
}
return 0;
}
R_API int btree_del(struct btree_node *proot, void *x, BTREE_CMP(cmp), BTREE_DEL(del)) {
struct btree_node *p = btree_search (proot, x, cmp, 1);
if (p) {
// p->right =
btree_remove (p->left, del);
return R_TRUE;
}
return R_FALSE;
}
R_API bool btree_del(struct btree_node *proot, void *x, BTREE_CMP(cmp), BTREE_DEL(del)) {
struct btree_node *p = btree_search (proot, x, cmp, 1);
if (p) {
// p->right =
btree_remove (p->left, del);
p->left = NULL;
return true;
}
return false;
}
TEST(BTree, Remove)
{
struct btree_s tree;
btree_init(&tree, 3);
int i;
for (i = 0; i < 10; i++) {
btree_insert(&tree, i);
}
btree_dump(&tree);
btree_remove(&tree, 5);
btree_dump(&tree);
btree_remove(&tree, 9);
btree_dump(&tree);
btree_remove(&tree, 8);
btree_dump(&tree);
btree_destroy(&tree);
}
static void dmd_free(void *p, const char *file, int line)
{
struct dmd_memblock *mb, sb;
// debug2("free %s:%d", file, line);
sb.ptr = p;
mb = btree_get(&dmd_tree, &sb);
if (!mb) {
putlog(LOG_MISC, "*", "*** DMD: ATTEMPTING TO FREE NON-MALLOC'D PTR: %s:%d",
file, line);
return;
}
btree_remove(&dmd_tree, mb);
free(p);
}
TEST(BTree, RemoveALot)
{
struct btree_s tree;
btree_init(&tree, 3);
int i;
for (i = 0; i < 1000000; i++) {
btree_insert(&tree, i);
}
for (i = 10; i < 999992; i++) {
btree_remove(&tree, i);
}
btree_dump(&tree);
btree_destroy(&tree);
}
int main(int argc, char **argv)
{
BTree *tree = btree_create(int_compare);
int n = atoi(argv[1]);
int a[n];
//int a[] = {1, 3, 2, 5, -1, 19, 15, 45, 9, 6, -4};
n = sizeof(a) / sizeof(a[0]);
//n = 3;
for (int i = 0; i < n; ++i) {
//a[i] = i + 1;
a[i] = rand() % 1000;
btree_insert(tree, (void*)&a[i]);
}
for (int i = 0; i < n / 2; ++i) {
btree_remove(btree_find(tree, &a[i]));
}
int expected_height = 2 * ceil(log(n + 1) / log(2)) + 1;
btree_dump_dot(tree, node_attrs);
btree_destroy(tree);
}
TEST(BTree, RemoveALot1)
{
struct btree_s tree;
btree_init(&tree, 3);
int i;
srand(time(0));
for (i = 0; i < 100000; i++) {
btree_insert(&tree, i);
}
btree_check(tree.root);
for (i = 0; i < 99992; i += (rand() % 3 + 1) ) {
btree_remove(&tree, i);
}
btree_destroy(&tree);
}
int main(void) {
btree_t bt;
btree_node_t *n;
char datatbl[] = {'a', 'b', 'd', 'd', 'a'};
btree_create(&bt);
btree_insert(&bt, btree_node_create(&datatbl[0]));
btree_insert(&bt, btree_node_create(&datatbl[1]));
btree_insert(&bt, btree_node_create(&datatbl[2]));
n = btree_node_create(&datatbl[3]);
btree_insert(&bt, n);
btree_remove(&bt, n, false);
btree_node_release(n);
btree_insert(&bt, btree_node_create(&datatbl[4]));
btree_release(&bt);
printf("Last Error: %s (%d)\r\n",
libnet_str_error(libnet_error_get()), libnet_error_get());
return 0;
}
int main(int argc, char ** argv)
{
int i;
// do we have verbose output?
bool ga_testing = false;
if (argc > 1)
{
for (i = 1; i < argc; ++i)
{
if (!strcmp(argv[1],"-ga"))
{
ga_testing = true;
break;
}
}
}
// initialize
btree * tree = create_btree(16);
bool flags[MAX_KEY];
for (i = 0; i < MAX_KEY; ++i)
flags[i] = false;
// get starting time
struct timespec start, stop;
clock_gettime(CLOCK_REALTIME,&start);
// what we're timing
for (int n = 0; n < TEST_SIZE; ++n)
{
// pick a key
btree_key_t key = random_key(MAX_KEY);
// is the key in the tree?
btree_data_t data = btree_find(tree,key);
if (data == NULL_DATA)
{
btree_insert(tree,key,(btree_data_t)key);
flags[key] = true;
}
else
{
btree_remove(tree,key);
flags[key] = false;
}
}
// calculate run time
clock_gettime(CLOCK_REALTIME,&stop);
double run_time = (stop.tv_sec - start.tv_sec) + (double)(stop.tv_nsec - start.tv_nsec) / 1000000000.0;
#if defined(VERIFY)
// verify
for (btree_key_t k = 0; k < MAX_KEY; ++k)
{
if (NULL_DATA == btree_find(tree,k))
{
if (flags[k])
fprintf(stderr,"VERIFICATION ERROR: %l found, and shouldn't have been\n",k);
}
else
{
if (!flags[k])
fprintf(stderr,"VERIFICATION ERROR: %l not found, and should have been\n",k);
}
}
#endif
// clean up
free_btree(tree);
// report runtime
if (ga_testing)
fprintf(stdout,"%f",run_time);
else
fprintf(stdout,"\ntreebench (Std. C) run time: %f\n\n",run_time);
fflush(stdout);
// done
return 0;
}
int running_screen() {
int n_items = 5;
// Itens no menu
char list[5][15] = { "Inserir", "Pesquisar", "Remover", "Imprimir DFS", "Voltar" };
int opt;
print_header();
int i;
for (i = 0; i < n_items; ++i) {
printf(" %d) %s\n", i+1, list[i]);
}
printf("\n");
printf(" Digite uma opção: ");
scanf("%d%*c", &opt);
int key;
node_position pos;
switch (opt) {
case 1: // Inserir
if (n_keys == max_keys) {
snprintf(msg, MSG_LEN, " O máximo de chaves adicionáveis para essa demo é %d.", max_keys);
}
else {
printf(" Digite uma CHAVE que será associada ao VALOR \'%s\': ", values[n_keys]);
scanf("%d", &key);
pos = btree_insert(tree, key, values[n_keys]);
if (pos.node == NULL) {
snprintf(msg, MSG_LEN, " Inserção falhou. A CHAVE %d já existe na B-Tree.", key);
}
else {
snprintf(msg, MSG_LEN, " Inserção da CHAVE %d associada ao VALOR \'%s\' realizada com sucesso.",
key, values[n_keys]);
n_keys++;
}
}
break;
case 2: // Pesquisar
printf(" Digite uma CHAVE para pesquisar: ");
scanf("%d", &key);
pos = btree_find(tree, key);
if (pos.node == NULL) {
snprintf(msg, MSG_LEN, " A CHAVE %d não foi encontrada na B-Tree.", key);
}
else {
snprintf(msg, MSG_LEN, " A CHAVE %d foi encontrada associada ao VALOR \'%s\'.",
key, (char*) pos.node->keys[pos.index]->value);
}
break;
case 3: // Remover
printf(" Digite uma CHAVE para remover: ");
scanf("%d", &key);
pos = btree_remove(tree, key);
if (pos.node == NULL) {
snprintf(msg, MSG_LEN, " A CHAVE %d não foi encontrada na B-Tree.", key);
}
else {
snprintf(msg, MSG_LEN, " A CHAVE %d foi removida com sucesso.", key);
}
break;
case 4: // Imprimir
printf(" Executando uma DFS na B-Tree:\n");
btree_dfs(tree);
printf(" Pressione ENTER para continuar. ");
getchar();
break;
case 5: // Voltar/Sair
snprintf(msg, MSG_LEN, " Deletando B-Tree e voltando ao menu");
goodbye();
// Única deleção de uma B-Tree
btree_delete_h(tree);
return HOME;
break;
default:
snprintf(msg, MSG_LEN, " Opção inválida");
return RUNNING;
break;
}
return RUNNING;
}
/* Removes the entry from the table */
void
h_table_remove( h_table_t *table, char *key )
{
btree_remove( table->tree, key );
}
