コード例 #1
0
ファイル: cat.c プロジェクト: kjk/sophia
int sp_catown(spcat *c, uint32_t idx, spv *v)
{
    register sppage *p = c->i[idx];
    /* equal or equal min or equal max */
    switch (cmpkey(c, p, v->key, v->size)) {
    case  0:
        return 1;
    case -1: /* key > page */
        /* key > max */
        if (idx == c->count-1)
            return 1;
        break;
    case  1: /* key < page */
        /* key < min */
        if (idx == 0)
            return 1;
        break;
    }
    /* key > page && key < page+1.min */
    if (c->cmp(v->key, v->size,
               c->i[idx + 1]->min->key,
               c->i[idx + 1]->min->size, c->cmparg) == -1)
        return 1;
    return 0;
}
コード例 #2
0
ファイル: check_ahtable.c プロジェクト: vavrusa/hat-trie
void test_ahtable_sorted_iteration()
{
    fprintf(stderr, "iterating in order through %zu keys ... \n", k);

    ahtable_iter_t i;
    ahtable_iter_begin(T, &i, true);

    size_t count = 0;
    value_t* u;
    value_t  v;

    char* prev_key = malloc(m_high + 1);
    size_t prev_len = 0;

    const char *key = NULL;
    size_t len = 0;

    while (!ahtable_iter_finished(&i)) {
        memcpy(prev_key, key, len);
        prev_len = len;
        ++count;

        key = ahtable_iter_key(&i, &len);
        if (prev_key != NULL && cmpkey(prev_key, prev_len, key, len) > 0) {
            fprintf(stderr, "[error] iteration is not correctly ordered.\n");
        }

        u  = ahtable_iter_val(&i);
        v  = str_map_get(M, key, len);

        if (*u != v) {
            if (v == 0) {
                fprintf(stderr, "[error] incorrect iteration (%lu, %lu)\n", *u, v);
            }
            else {
                fprintf(stderr, "[error] incorrect iteration tally (%lu, %lu)\n", *u, v);
            }
        }

        // this way we will see an error if the same key is iterated through
        // twice
        str_map_set(M, key, len, 0);

        ahtable_iter_next(&i);
    }

    ahtable_iter_free(&i);
    free(prev_key);

    fprintf(stderr, "done.\n");
}
コード例 #3
0
ファイル: avl.c プロジェクト: corywalker/puppybits
/* Search |tree| for an item matching |item|, and return it if found.
   Otherwise return |NULL|. */
struct AVLNode *
AVL_Find(struct AVLNode *p, const void *item, AVLKEYCOMP cmpkey)
{
	int dir;

	for (; p != NULL; p = p->Link[dir]) {
		int cmp = cmpkey(item, p);

		if (cmp == 0)
			break;

		dir = cmp > 0;
	}

	return (struct AVLNode *)p;
}
コード例 #4
0
ファイル: cat.c プロジェクト: Aiolossong/rippled
sppage*
sp_catfind(spcat *c, char *rkey, int size, uint32_t *index)
{
	register int min = 0;
	register int max = c->count - 1;
	while (max >= min) {
		register int mid = min + ((max - min) >> 1);
		switch (cmpkey(c, c->i[mid], rkey, size)) {
		case -1: min = mid + 1;
			continue;
		case  1: max = mid - 1;
			continue;
		default: *index = mid;
			return c->i[mid];
		}
	}
	*index = min;
	return NULL;
}
コード例 #5
0
ファイル: avl.c プロジェクト: corywalker/puppybits
/* Find node <= item */
struct AVLNode *
AVL_FindPrev(struct AVLNode *p, const void *item, AVLKEYCOMP cmpkey)
{
	int dir;
	struct AVLNode *l;

	if (p == NULL)
		return p;

	for (; p != NULL; p = p->Link[dir]) {
		int cmp = cmpkey(item, p);

		if (cmp == 0)
			return p;

		l = p;
		dir = cmp > 0;
	}

	if (dir == 0)
		return AVL_Prev(l);
	else
		return l;
}
コード例 #6
0
ファイル: check_hattrie.c プロジェクト: mikepb/hat-trie
void test_hattrie_sorted_iteration()
{
    fprintf(stderr, "iterating in order through %zu keys ... \n", k);

    hattrie_iter_t* i = hattrie_iter_begin(T, true);

    size_t count = 0;
    value_t* u;
    value_t  v;

    char* key_copy = malloc(m_high + 1);
    char* prev_key = malloc(m_high + 1);
    memset(prev_key, 0, m_high + 1);
    size_t prev_len = 0;

    const char *key = NULL;
    size_t len = 0;

    while (!hattrie_iter_finished(i)) {
        memcpy(prev_key, key_copy, len);
        prev_key[len] = '\0';
        prev_len = len;
        ++count;

        key = hattrie_iter_key(i, &len);

        /* memory for key may be changed on iter, copy it */
        strncpy(key_copy, key, len);

        if (prev_key != NULL && cmpkey(prev_key, prev_len, key, len) > 0) {
            fprintf(stderr, "[error] iteration is not correctly ordered.\n");
        }

        u = hattrie_iter_val(i);
        v = str_map_get(M, key, len);

        if (*u != v) {
            if (v == 0) {
                fprintf(stderr, "[error] incorrect iteration (%lu, %lu)\n", *u, v);
            }
            else {
                fprintf(stderr, "[error] incorrect iteration tally (%lu, %lu)\n", *u, v);
            }
        }

        // this way we will see an error if the same key is iterated through
        // twice
        str_map_set(M, key, len, 0);

        hattrie_iter_next(i);
    }

    if (count != M->m) {
        fprintf(stderr, "[error] iterated through %zu element, expected %zu\n",
                count, M->m);
    }

    hattrie_iter_free(i);
    free(prev_key);
    free(key_copy);

    fprintf(stderr, "done.\n");
}