/* internal function for general removing by index */
int remove_book(long index)
{
Book *D;
Book tmp;
char *name;
char *title;
long size = (db.numberOfBooks - 1) * sizeof(Book);
title = db.arr[index].title;
name = db.arr[index].authors[0].last;
/* removing from trees */
avl = avl_delete(db.arr[index].id, avl);
trie_title = trie_delete(title, trie_title);
trie_name = trie_delete(name, trie_name);
/* moving the interesting node at the end */
tmp = db.arr[index];
memmove(db.arr+index, db.arr+index+1,
sizeof(Book)*(db.numberOfBooks-index-1));
db.arr[db.numberOfBooks - 1] = tmp;
/* first freeing any dynamic memory */
free(db.arr[db.numberOfBooks - 1].authors);
/* removing by reallocating by one Book size to free the coresponding
* memory of the interesting node */
D = realloc(db.arr, size);
if (D) {
/* replace and reduce the sum */
db.arr = D;
db.numberOfBooks--;
return 0;
} else
return -1;
}
int parse_and_print_to_stdout(const char * operation)
{
if (NULL == operation)
{
skip_line(stdin);
return -1;
}
if (0 == strcmp(OP_INSERT, operation))
{
if (0 != parse_insert(stdin, word_buffer, MAX_WORD_LEN))
return -1;
int word_num = trie_insert(word_buffer);
if (word_num < 0)
return -1;
printf("word number: %d\n", word_num);
}
if (0 == strcmp(OP_PREV, operation))
{
int number, start, end;
if (0 != parse_prev(stdin, &number, &start, &end))
return -1;
int word_num = trie_prev(number, start, end);
if (word_num < 0)
return -1;
printf("word number: %d\n", word_num);
}
if (0 == strcmp(OP_DELETE, operation))
{
int number;
if (0 != parse_delete(stdin, &number))
return -1;
int word_num = trie_delete(number);
if (word_num < 0)
return -1;
printf("deleted: %d\n", number);
}
if (0 == strcmp(OP_FIND, operation))
{
if (0 != parse_find(stdin, word_buffer, MAX_WORD_LEN))
return -1;
int find_result = trie_find(word_buffer, strlen(word_buffer));
if (find_result < 0)
return -1;
puts(find_result == 0 ? "YES" : "NO");
}
if (0 == strcmp(OP_CLEAR, operation))
{
if (0 != parse_clear(stdin))
return -1;
if (0 != trie_clear())
return -1;
puts("cleared");
}
return 0;
}
/*
* call-seq:
* delete(key)
*
* Delete a key from the Trie. Returns true if it deleted a key, nil otherwise.
*
*/
static VALUE rb_trie_delete(VALUE self, VALUE key) {
StringValue(key);
Trie *trie;
Data_Get_Struct(self, Trie, trie);
if(trie_delete(trie, (TrieChar*)RSTRING_PTR(key)))
return Qtrue;
else
return Qnil;
}
Bool
sb_trie_delete (SBTrie *sb_trie, const SBChar *key)
{
TrieChar *trie_key;
Bool ret;
trie_key = sb_map_char_to_alphabet_str (sb_trie->alpha_map, key);
ret = trie_delete (sb_trie->trie, trie_key);
free (trie_key);
return ret;
}
int main()
{
trie_node *root = NULL;
trie_pair *entry;
root = trie_insert(root, pair_new("dog\0", 2));
root = trie_insert(root, pair_new("cat\0", 3));
root = trie_insert(root, pair_new("top\0", 4));
root = trie_insert(root, pair_new("rat\0", 5));
trie_show(root, 0);
entry = trie_search(root, "cat");
trie_delete(root, "dog");
entry = trie_search(root, "dog");
}
int main(void)
{
static struct word word1 = {
.data = (uint8_t *)"aaa", .size = 4, .value = (void *)0xA};
static struct word word2 = {
.data = (uint8_t *)"aba", .size = 4, .value = (void *)0xB};
struct trie *obj = trie_new(NULL, dealloc);
assert(obj);
void *data;
bool ret;
ret = trie_insert(obj, word1.data, word1.size, word1.value, &data);
assert(ret);
assert(data == NULL);
// check the first insertion
ret = trie_at(obj, word1.data, word1.size, &data);
assert(ret);
assert(data == word1.value);
ret = trie_insert(obj, word2.data, word2.size, word2.value, &data);
assert(ret);
assert(data == NULL);
// check all after all insertions
ret = trie_at(obj, word1.data, word1.size, &data);
assert(ret);
assert(data == word1.value);
ret = trie_at(obj, word2.data, word2.size, &data);
assert(ret);
assert(data == word2.value);
for (struct trie_node *i = trie_begin(obj); i;
i = trie_next_delete(obj, i)) {
char *str = NULL;
if (trie_data(i, (void *)&str))
printf("trie next: 0x%x\n", (unsigned int)str);
else
printf("trie next failed!\n");
}
trie_delete(&obj);
assert(obj == NULL);
return 0;
}
bool
ATTrie :: remove(const QString & key)
{
if (data->trie == NULL)
return false;
if (key.length() > AT_ALPHA_KEY_MAX_LENGTH - 1)
return false;
for (int i = 0; i < key.length(); i++)
data->alpha_key[i] = key[i].unicode();
data->alpha_key[key.length()] = 0;
Bool ret = trie_delete(data->trie, data->alpha_key);
return ret == true;
}
gboolean falcon_cache_delete(falcon_cache_t *cache, const gchar *name)
{
trie_node_t *node = NULL;
g_return_val_if_fail(cache, FALSE);
g_return_val_if_fail(name, FALSE);
g_mutex_lock(cache->lock);
node = trie_find(cache->objects, name);
if (!node) {
g_mutex_unlock(cache->lock);
g_warning(_("Failed to delete \"%s\", it does not exist in the cache."),
name);
return FALSE;
}
trie_delete(cache->objects, name, (trie_free_func)falcon_object_free);
cache->count--;
g_mutex_unlock(cache->lock);
return TRUE;
}
int
main (void)
{
Trie *test_trie;
DictRec *dict_p;
TrieData trie_data;
Bool is_failed;
int n_entries, n_dels, i;
TrieState *trie_root_state;
TrieIterator *trie_it;
msg_step ("Preparing trie");
test_trie = en_trie_new ();
if (!test_trie) {
fprintf (stderr, "Fail to create test trie\n");
goto err_trie_not_created;
}
/* store */
msg_step ("Adding data to trie");
for (dict_p = dict_src; dict_p->key; dict_p++) {
if (!trie_store (test_trie, dict_p->key, dict_p->data)) {
printf ("Failed to add key '%ls', data %d.\n",
(wchar_t *)dict_p->key, dict_p->data);
goto err_trie_created;
}
}
/* retrieve */
msg_step ("Retrieving data from trie");
is_failed = FALSE;
for (dict_p = dict_src; dict_p->key; dict_p++) {
if (!trie_retrieve (test_trie, dict_p->key, &trie_data)) {
printf ("Failed to retrieve key '%ls'.\n", (wchar_t *)dict_p->key);
is_failed = TRUE;
}
if (trie_data != dict_p->data) {
printf ("Wrong data for key '%ls'; expected %d, got %d.\n",
(wchar_t *)dict_p->key, dict_p->data, trie_data);
is_failed = TRUE;
}
}
if (is_failed) {
printf ("Trie store/retrieval test failed.\n");
goto err_trie_created;
}
/* delete */
msg_step ("Deleting some entries from trie");
n_entries = dict_src_n_entries ();
srand (time (NULL));
for (n_dels = n_entries/3 + 1; n_dels > 0; n_dels--) {
/* pick an undeleted entry */
do {
i = rand () % n_entries;
} while (TRIE_DATA_READ == dict_src[i].data);
printf ("Deleting '%ls'\n", (wchar_t *)dict_src[i].key);
if (!trie_delete (test_trie, dict_src[i].key)) {
printf ("Failed to delete '%ls'\n", (wchar_t *)dict_src[i].key);
is_failed = TRUE;
}
dict_src[i].data = TRIE_DATA_READ;
}
if (is_failed) {
printf ("Trie deletion test failed.\n");
goto err_trie_created;
}
/* retrieve */
msg_step ("Retrieving data from trie again after deletions");
for (dict_p = dict_src; dict_p->key; dict_p++) {
/* skip deleted entries */
if (TRIE_DATA_READ == dict_p->data)
continue;
if (!trie_retrieve (test_trie, dict_p->key, &trie_data)) {
printf ("Failed to retrieve key '%ls'.\n", (wchar_t *)dict_p->key);
is_failed = TRUE;
}
if (trie_data != dict_p->data) {
printf ("Wrong data for key '%ls'; expected %d, got %d.\n",
(wchar_t *)dict_p->key, dict_p->data, trie_data);
is_failed = TRUE;
}
}
if (is_failed) {
printf ("Trie retrival-after-deletion test failed.\n");
goto err_trie_created;
}
/* enumerate & check */
msg_step ("Iterating trie contents after deletions");
trie_root_state = trie_root (test_trie);
if (!trie_root_state) {
printf ("Failed to get trie root state\n");
goto err_trie_created;
}
trie_it = trie_iterator_new (trie_root_state);
if (!trie_it) {
printf ("Failed to get trie iterator\n");
goto err_trie_root_created;
}
while (trie_iterator_next (trie_it)) {
AlphaChar *key;
TrieData key_data, src_data;
key = trie_iterator_get_key (trie_it);
if (!key) {
printf ("Failed to get key from trie iterator\n");
is_failed = TRUE;
continue;
}
key_data = trie_iterator_get_data (trie_it);
if (TRIE_DATA_ERROR == key_data) {
printf ("Failed to get data from trie iterator for key '%ls'\n",
(wchar_t *)key);
is_failed = TRUE;
}
/* mark entries found in trie */
src_data = dict_src_get_data (key);
if (TRIE_DATA_ERROR == src_data) {
printf ("Extra entry in trie: key '%ls', data %d.\n",
(wchar_t *)key, key_data);
is_failed = TRUE;
} else if (src_data != key_data) {
printf ("Data mismatch for: key '%ls', expected %d, got %d.\n",
(wchar_t *)key, src_data, key_data);
is_failed = TRUE;
} else {
dict_src_set_data (key, TRIE_DATA_READ);
}
free (key);
}
/* check for unmarked entries, (i.e. missed in trie) */
for (dict_p = dict_src; dict_p->key; dict_p++) {
if (dict_p->data != TRIE_DATA_READ) {
printf ("Entry missed in trie: key '%ls', data %d.\n",
(wchar_t *)dict_p->key, dict_p->data);
is_failed = TRUE;
}
}
if (is_failed) {
printf ("Errors found in trie iteration after deletions.\n");
goto err_trie_it_created;
}
trie_iterator_free (trie_it);
trie_state_free (trie_root_state);
trie_free (test_trie);
return 0;
err_trie_it_created:
trie_iterator_free (trie_it);
err_trie_root_created:
trie_state_free (trie_root_state);
err_trie_created:
trie_free (test_trie);
err_trie_not_created:
return 1;
}
int main(int argc, char *argv[])
{
/* test_lookup(); */
/* Trivial tests
*/
trie_t *trie = trie_new();
trie_insert(trie, "abcde123456789");
trie_insert(trie, "abcde123654789");
trie_insert(trie, "abcde123654789");
trie_insert(trie, "abcdefghi");
trie_insert(trie, "coucou");
trie_insert(trie, "coucou chez vous");
trie_insert(trie, "debout !");
trie_compile(trie, false);
trie_inspect(trie, true);
#define ASSERT_TRUE(str) \
if (!trie_lookup(trie, str)) { \
printf("\"%s\" not found in trie\n", str); \
return 1; \
}
#define ASSERT_FALSE(str) \
if (trie_lookup(trie, str)) { \
printf("\"%s\" found in trie\n", str); \
return 1; \
}
ASSERT_FALSE("");
ASSERT_FALSE("coucou ");
ASSERT_FALSE("abcde123");
ASSERT_FALSE("abcde");
ASSERT_FALSE("coucou chez vous tous");
ASSERT_TRUE("abcde123456789");
ASSERT_TRUE("abcde123456789");
ASSERT_TRUE("abcde123654789");
ASSERT_TRUE("abcdefghi");
ASSERT_TRUE("coucou");
ASSERT_TRUE("coucou chez vous");
ASSERT_TRUE("debout !");
trie_delete(&trie);
/* Perf test
*/
if (argc > 1) {
trie = create_trie_from_file(argv[1]);
trie_inspect(trie, true);
check_trie_with_file(trie, argv[1]);
if (argc > 2) {
const uint32_t how_many = 8 * 1000 * 1000;
struct timeval start, end;
double diff;
gettimeofday(&start, NULL);
for (uint32_t i = 0 ; i < how_many ; ++i) {
trie_lookup(trie, argv[2]);
}
gettimeofday(&end, NULL);
diff = (end.tv_sec - start.tv_sec) + (double)(end.tv_usec - start.tv_usec) / 10e6;
printf("%u lookups per second\n", (int)(how_many / diff));
trie_match_t match;
gettimeofday(&start, NULL);
for (uint32_t i = 0 ; i < how_many ; ++i) {
trie_lookup_match(trie, argv[2], &match);
}
gettimeofday(&end, NULL);
diff = (end.tv_sec - start.tv_sec) + (double)(end.tv_usec - start.tv_usec) / 10e6;
printf("%u lookups per second\n", (int)(how_many / diff));
}
trie_delete(&trie);
}
return 0;
}
