diff --git a/src/box/memtx_hash.cc b/src/box/memtx_hash.cc
index 54ba256911594c1661c8f0c389bece8307d7a0c2..e2c281a142c783d1931d33f12ac481fb1b2dae4f 100644
--- a/src/box/memtx_hash.cc
+++ b/src/box/memtx_hash.cc
@@ -158,7 +158,7 @@ typedef uint32_t hash_t;
struct hash_iterator {
struct iterator base; /* Must be the first member. */
struct light_index_core *hash_table;
- struct light_index_iterator hitr;
+ struct light_index_iterator iterator;
};
void
@@ -173,8 +173,8 @@ hash_iterator_ge(struct iterator *ptr)
{
assert(ptr->free == hash_iterator_free);
struct hash_iterator *it = (struct hash_iterator *) ptr;
- struct tuple **res = light_index_itr_get_and_next(it->hash_table,
- &it->hitr);
+ struct tuple **res = light_index_iterator_get_and_next(it->hash_table,
+ &it->iterator);
return res ? *res : 0;
}
@@ -184,12 +184,12 @@ hash_iterator_gt(struct iterator *ptr)
assert(ptr->free == hash_iterator_free);
ptr->next = hash_iterator_ge;
struct hash_iterator *it = (struct hash_iterator *) ptr;
- struct tuple **res = light_index_itr_get_and_next(it->hash_table,
- &it->hitr);
+ struct tuple **res = light_index_iterator_get_and_next(it->hash_table,
+ &it->iterator);
if (!res)
return 0;
- res = light_index_itr_get_and_next(it->hash_table,
- &it->hitr);
+ res = light_index_iterator_get_and_next(it->hash_table,
+ &it->iterator);
return res ? *res : 0;
}
@@ -339,7 +339,7 @@ MemtxHash::allocIterator() const
it->base.next = hash_iterator_ge;
it->base.free = hash_iterator_free;
it->hash_table = hash_table;
- light_index_itr_begin(it->hash_table, &it->hitr);
+ light_index_iterator_begin(it->hash_table, &it->iterator);
return (struct iterator *) it;
}
@@ -356,22 +356,22 @@ MemtxHash::initIterator(struct iterator *ptr, enum iterator_type type,
switch (type) {
case ITER_GT:
if (part_count != 0) {
- light_index_itr_key(it->hash_table, &it->hitr,
+ light_index_iterator_key(it->hash_table, &it->iterator,
key_hash(key, key_def), key);
it->base.next = hash_iterator_gt;
} else {
- light_index_itr_begin(it->hash_table, &it->hitr);
+ light_index_iterator_begin(it->hash_table, &it->iterator);
it->base.next = hash_iterator_ge;
}
break;
case ITER_ALL:
- light_index_itr_begin(it->hash_table, &it->hitr);
+ light_index_iterator_begin(it->hash_table, &it->iterator);
it->base.next = hash_iterator_ge;
break;
case ITER_EQ:
assert(part_count > 0);
- light_index_itr_key(it->hash_table, &it->hitr,
- key_hash(key, key_def), key);
+ light_index_iterator_key(it->hash_table, &it->iterator,
+ key_hash(key, key_def), key);
it->base.next = hash_iterator_eq;
break;
default:
@@ -387,7 +387,7 @@ void
MemtxHash::createReadViewForIterator(struct iterator *iterator)
{
struct hash_iterator *it = (struct hash_iterator *) iterator;
- light_index_itr_freeze(it->hash_table, &it->hitr);
+ light_index_iterator_freeze(it->hash_table, &it->iterator);
}
/**
@@ -398,7 +398,7 @@ void
MemtxHash::destroyReadViewForIterator(struct iterator *iterator)
{
struct hash_iterator *it = (struct hash_iterator *) iterator;
- light_index_itr_destroy(it->hash_table, &it->hitr);
+ light_index_iterator_destroy(it->hash_table, &it->iterator);
}
/* }}} */
diff --git a/src/box/memtx_tree.cc b/src/box/memtx_tree.cc
index 4f0b5d37dafabde06805e4d47067e0d5ff830848..bd1b3287b9c16ca6136b1c7553974b2df68b5c14 100644
--- a/src/box/memtx_tree.cc
+++ b/src/box/memtx_tree.cc
@@ -105,10 +105,10 @@ static struct tuple *
tree_iterator_fwd(struct iterator *iterator)
{
struct tree_iterator *it = tree_iterator(iterator);
- tuple **res = memtx_tree_itr_get_elem(it->tree, &it->tree_iterator);
+ tuple **res = memtx_tree_iterator_get_elem(it->tree, &it->tree_iterator);
if (!res)
return 0;
- memtx_tree_itr_next(it->tree, &it->tree_iterator);
+ memtx_tree_iterator_next(it->tree, &it->tree_iterator);
return *res;
}
@@ -116,10 +116,10 @@ static struct tuple *
tree_iterator_bwd(struct iterator *iterator)
{
struct tree_iterator *it = tree_iterator(iterator);
- tuple **res = memtx_tree_itr_get_elem(it->tree, &it->tree_iterator);
+ tuple **res = memtx_tree_iterator_get_elem(it->tree, &it->tree_iterator);
if (!res)
return 0;
- memtx_tree_itr_prev(it->tree, &it->tree_iterator);
+ memtx_tree_iterator_prev(it->tree, &it->tree_iterator);
return *res;
}
@@ -127,14 +127,14 @@ static struct tuple *
tree_iterator_fwd_check_equality(struct iterator *iterator)
{
struct tree_iterator *it = tree_iterator(iterator);
- tuple **res = memtx_tree_itr_get_elem(it->tree, &it->tree_iterator);
+ tuple **res = memtx_tree_iterator_get_elem(it->tree, &it->tree_iterator);
if (!res)
return 0;
if (memtx_tree_compare_key(*res, &it->key_data, it->key_def) != 0) {
it->tree_iterator = memtx_tree_invalid_iterator();
return 0;
}
- memtx_tree_itr_next(it->tree, &it->tree_iterator);
+ memtx_tree_iterator_next(it->tree, &it->tree_iterator);
return *res;
}
@@ -142,10 +142,10 @@ static struct tuple *
tree_iterator_fwd_check_next_equality(struct iterator *iterator)
{
struct tree_iterator *it = tree_iterator(iterator);
- tuple **res = memtx_tree_itr_get_elem(it->tree, &it->tree_iterator);
+ tuple **res = memtx_tree_iterator_get_elem(it->tree, &it->tree_iterator);
if (!res)
return 0;
- memtx_tree_itr_next(it->tree, &it->tree_iterator);
+ memtx_tree_iterator_next(it->tree, &it->tree_iterator);
iterator->next = tree_iterator_fwd_check_equality;
return *res;
}
@@ -154,7 +154,7 @@ static struct tuple *
tree_iterator_bwd_skip_one(struct iterator *iterator)
{
struct tree_iterator *it = tree_iterator(iterator);
- memtx_tree_itr_prev(it->tree, &it->tree_iterator);
+ memtx_tree_iterator_prev(it->tree, &it->tree_iterator);
iterator->next = tree_iterator_bwd;
return tree_iterator_bwd(iterator);
}
@@ -163,14 +163,14 @@ static struct tuple *
tree_iterator_bwd_check_equality(struct iterator *iterator)
{
struct tree_iterator *it = tree_iterator(iterator);
- tuple **res = memtx_tree_itr_get_elem(it->tree, &it->tree_iterator);
+ tuple **res = memtx_tree_iterator_get_elem(it->tree, &it->tree_iterator);
if (!res)
return 0;
if (memtx_tree_compare_key(*res, &it->key_data, it->key_def) != 0) {
it->tree_iterator = memtx_tree_invalid_iterator();
return 0;
}
- memtx_tree_itr_prev(it->tree, &it->tree_iterator);
+ memtx_tree_iterator_prev(it->tree, &it->tree_iterator);
return *res;
}
@@ -178,7 +178,7 @@ static struct tuple *
tree_iterator_bwd_skip_one_check_next_equality(struct iterator *iterator)
{
struct tree_iterator *it = tree_iterator(iterator);
- memtx_tree_itr_prev(it->tree, &it->tree_iterator);
+ memtx_tree_iterator_prev(it->tree, &it->tree_iterator);
iterator->next = tree_iterator_bwd_check_equality;
return tree_iterator_bwd_check_equality(iterator);
}
@@ -313,7 +313,7 @@ MemtxTree::initIterator(struct iterator *iterator, enum iterator_type type,
if (iterator_type_is_reverse(type))
it->tree_iterator = memtx_tree_invalid_iterator();
else
- it->tree_iterator = memtx_tree_itr_first(&tree);
+ it->tree_iterator = memtx_tree_iterator_first(&tree);
} else {
if (type == ITER_ALL || type == ITER_EQ || type == ITER_GE || type == ITER_LT) {
it->tree_iterator = memtx_tree_lower_bound(&tree, &it->key_data, &exact);
@@ -412,7 +412,7 @@ MemtxTree::createReadViewForIterator(struct iterator *iterator)
{
struct tree_iterator *it = tree_iterator(iterator);
struct memtx_tree *tree = (struct memtx_tree *)it->tree;
- memtx_tree_itr_freeze(tree, &it->tree_iterator);
+ memtx_tree_iterator_freeze(tree, &it->tree_iterator);
}
/**
@@ -424,5 +424,5 @@ MemtxTree::destroyReadViewForIterator(struct iterator *iterator)
{
struct tree_iterator *it = tree_iterator(iterator);
struct memtx_tree *tree = (struct memtx_tree *)it->tree;
- memtx_tree_itr_destroy(tree, &it->tree_iterator);
+ memtx_tree_iterator_destroy(tree, &it->tree_iterator);
}
diff --git a/src/box/vinyl.c b/src/box/vinyl.c
index 17a104ed547875cc9ddbf9caaa590829cd6f20d9..967ab1f34107f809783a79c22df9ad0db4b16bfe 100644
--- a/src/box/vinyl.c
+++ b/src/box/vinyl.c
@@ -1556,12 +1556,12 @@ static void
vy_mem_delete(struct vy_mem *index)
{
assert(index == index->tree.arg);
- struct vy_mem_tree_iterator itr = vy_mem_tree_itr_first(&index->tree);
- while (!vy_mem_tree_itr_is_invalid(&itr)) {
+ struct vy_mem_tree_iterator itr = vy_mem_tree_iterator_first(&index->tree);
+ while (!vy_mem_tree_iterator_is_invalid(&itr)) {
struct vy_tuple *v =
- *vy_mem_tree_itr_get_elem(&index->tree, &itr);
+ *vy_mem_tree_iterator_get_elem(&index->tree, &itr);
vy_tuple_unref(v);
- vy_mem_tree_itr_next(&index->tree, &itr);
+ vy_mem_tree_iterator_next(&index->tree, &itr);
}
vy_mem_tree_destroy(&index->tree);
free(index);
@@ -2747,9 +2747,10 @@ vy_index_add_range(struct vy_index *index, struct vy_range *range)
/* Check in-memory indexes */
for (struct vy_mem *mem = range->mem; mem != NULL; mem = mem->next) {
- struct vy_mem_tree_iterator itr = vy_mem_tree_itr_first(&mem->tree);
- if (!vy_mem_tree_itr_is_invalid(&itr)) {
- struct vy_tuple *v = *vy_mem_tree_itr_get_elem(&mem->tree, &itr);
+ struct vy_mem_tree_iterator itr =
+ vy_mem_tree_iterator_first(&mem->tree);
+ if (!vy_mem_tree_iterator_is_invalid(&itr)) {
+ struct vy_tuple *v = *vy_mem_tree_iterator_get_elem(&mem->tree, &itr);
if (min_key == NULL ||
vy_tuple_compare(v->data, min_key, index->key_def) < 0) {
min_key = v->data;
@@ -7429,9 +7430,9 @@ vy_tmp_run_iterator_next(struct vy_iter *virt_iterator)
void
vy_tmp_run_iterator_open(struct vy_iter *virt_iterator, struct vy_index *index,
- struct vy_run *run, int fd,
- struct vy_filterif *compression,
- enum vy_order order, char *key)
+ struct vy_run *run, int fd,
+ struct vy_filterif *compression,
+ enum vy_order order, char *key)
{
static struct vy_iterif vif = {
.close = vy_tmp_run_iterator_close,
@@ -7520,7 +7521,7 @@ vy_mem_iterator_close(struct vy_mem_iterator *itr);
static struct vy_tuple *
vy_mem_iterator_curr_tuple(struct vy_mem_iterator *itr)
{
- return *vy_mem_tree_itr_get_elem(&itr->mem->tree, &itr->curr_pos);
+ return *vy_mem_tree_iterator_get_elem(&itr->mem->tree, &itr->curr_pos);
}
/**
@@ -7532,10 +7533,10 @@ static int
vy_mem_iterator_step(struct vy_mem_iterator *itr)
{
if (itr->order == VINYL_LE || itr->order == VINYL_LT)
- vy_mem_tree_itr_prev(&itr->mem->tree, &itr->curr_pos);
+ vy_mem_tree_iterator_prev(&itr->mem->tree, &itr->curr_pos);
else
- vy_mem_tree_itr_next(&itr->mem->tree, &itr->curr_pos);
- if (vy_mem_tree_itr_is_invalid(&itr->curr_pos))
+ vy_mem_tree_iterator_next(&itr->mem->tree, &itr->curr_pos);
+ if (vy_mem_tree_iterator_is_invalid(&itr->curr_pos))
return 1;
itr->curr_tuple = vy_mem_iterator_curr_tuple(itr);
return 0;
@@ -7551,7 +7552,7 @@ vy_mem_iterator_step(struct vy_mem_iterator *itr)
static int
vy_mem_iterator_find_lsn(struct vy_mem_iterator *itr)
{
- assert(!vy_mem_tree_itr_is_invalid(&itr->curr_pos));
+ assert(!vy_mem_tree_iterator_is_invalid(&itr->curr_pos));
assert(itr->curr_tuple == vy_mem_iterator_curr_tuple(itr));
while (itr->curr_tuple->lsn > itr->vlsn) {
if (vy_mem_iterator_step(itr) != 0 ||
@@ -7564,12 +7565,12 @@ vy_mem_iterator_find_lsn(struct vy_mem_iterator *itr)
}
if (itr->order == VINYL_LE || itr->order == VINYL_LT) {
struct vy_mem_tree_iterator prev_pos = itr->curr_pos;
- vy_mem_tree_itr_prev(&itr->mem->tree, &prev_pos);
+ vy_mem_tree_iterator_prev(&itr->mem->tree, &prev_pos);
- while (!vy_mem_tree_itr_is_invalid(&prev_pos)) {
+ while (!vy_mem_tree_iterator_is_invalid(&prev_pos)) {
struct vy_tuple *prev_tuple =
- *vy_mem_tree_itr_get_elem(&itr->mem->tree,
- &prev_pos);
+ *vy_mem_tree_iterator_get_elem(&itr->mem->tree,
+ &prev_pos);
struct key_def *key_def = itr->mem->key_def;
if (prev_tuple->lsn > itr->vlsn ||
vy_tuple_compare(itr->curr_tuple->data,
@@ -7577,7 +7578,7 @@ vy_mem_iterator_find_lsn(struct vy_mem_iterator *itr)
break;
itr->curr_pos = prev_pos;
itr->curr_tuple = prev_tuple;
- vy_mem_tree_itr_prev(&itr->mem->tree, &prev_pos);
+ vy_mem_tree_iterator_prev(&itr->mem->tree, &prev_pos);
}
}
return 0;
@@ -7624,12 +7625,12 @@ vy_mem_iterator_start(struct vy_mem_iterator *itr)
itr->curr_pos = vy_mem_tree_invalid_iterator();
} else {
itr->order = VINYL_GE;
- itr->curr_pos = vy_mem_tree_itr_first(&itr->mem->tree);
+ itr->curr_pos = vy_mem_tree_iterator_first(&itr->mem->tree);
}
if (itr->order == VINYL_LT || itr->order == VINYL_LE)
- vy_mem_tree_itr_prev(&itr->mem->tree, &itr->curr_pos);
- if (vy_mem_tree_itr_is_invalid(&itr->curr_pos)) {
+ vy_mem_tree_iterator_prev(&itr->mem->tree, &itr->curr_pos);
+ if (vy_mem_tree_iterator_is_invalid(&itr->curr_pos)) {
vy_mem_iterator_close(itr);
return 1;
}
@@ -7650,7 +7651,7 @@ vy_mem_iterator_check_version(struct vy_mem_iterator *itr)
return;
itr->version = itr->mem->version;
struct vy_tuple **record =
- vy_mem_tree_itr_get_elem(&itr->mem->tree, &itr->curr_pos);
+ vy_mem_tree_iterator_get_elem(&itr->mem->tree, &itr->curr_pos);
if (record != NULL && *record == itr->curr_tuple)
return;
struct tree_mem_key tree_key;
@@ -7714,7 +7715,7 @@ vy_mem_iterator_next_key(struct vy_mem_iterator *itr)
if (itr->search_ended ||
(!itr->search_started && vy_mem_iterator_start(itr) != 0))
return 1;
- assert(!vy_mem_tree_itr_is_invalid(&itr->curr_pos));
+ assert(!vy_mem_tree_iterator_is_invalid(&itr->curr_pos));
vy_mem_iterator_check_version(itr);
assert(itr->curr_tuple == vy_mem_iterator_curr_tuple(itr));
struct key_def *key_def = itr->mem->key_def;
@@ -7748,18 +7749,18 @@ vy_mem_iterator_next_lsn(struct vy_mem_iterator *itr)
if (itr->search_ended ||
(!itr->search_started && vy_mem_iterator_start(itr) != 0))
return 1;
- assert(!vy_mem_tree_itr_is_invalid(&itr->curr_pos));
+ assert(!vy_mem_tree_iterator_is_invalid(&itr->curr_pos));
vy_mem_iterator_check_version(itr);
assert(itr->curr_tuple == vy_mem_iterator_curr_tuple(itr));
struct key_def *key_def = itr->mem->key_def;
struct vy_mem_tree_iterator next_pos = itr->curr_pos;
- vy_mem_tree_itr_next(&itr->mem->tree, &next_pos);
- if (vy_mem_tree_itr_is_invalid(&next_pos))
+ vy_mem_tree_iterator_next(&itr->mem->tree, &next_pos);
+ if (vy_mem_tree_iterator_is_invalid(&next_pos))
return 1; /* EOF */
struct vy_tuple *next_tuple =
- *vy_mem_tree_itr_get_elem(&itr->mem->tree, &next_pos);
+ *vy_mem_tree_iterator_get_elem(&itr->mem->tree, &next_pos);
if (vy_tuple_compare(itr->curr_tuple->data,
next_tuple->data, key_def) == 0) {
itr->curr_pos = next_pos;
@@ -7801,11 +7802,11 @@ vy_mem_iterator_restore(struct vy_mem_iterator *itr,
int rc = 0;
if (itr->order == VINYL_GE || itr->order == VINYL_GT || itr->order == VINYL_EQ) {
while (true) {
- vy_mem_tree_itr_prev(&itr->mem->tree, &pos);
- if (vy_mem_tree_itr_is_invalid(&pos))
+ vy_mem_tree_iterator_prev(&itr->mem->tree, &pos);
+ if (vy_mem_tree_iterator_is_invalid(&pos))
return rc;
struct vy_tuple *t =
- *vy_mem_tree_itr_get_elem(&itr->mem->tree, &pos);
+ *vy_mem_tree_iterator_get_elem(&itr->mem->tree, &pos);
int cmp = vy_tuple_compare(t->data, last_tuple->data, itr->mem->key_def);
if (cmp < 0 || (cmp == 0 && t->lsn >= last_tuple->lsn))
return rc;
@@ -7821,11 +7822,11 @@ vy_mem_iterator_restore(struct vy_mem_iterator *itr,
int cmp = vy_tuple_compare(itr->curr_tuple->data, last_tuple->data, itr->mem->key_def);
int64_t break_lsn = cmp == 0 ? last_tuple->lsn : itr->vlsn + 1;
while (true) {
- vy_mem_tree_itr_prev(&itr->mem->tree, &pos);
- if (vy_mem_tree_itr_is_invalid(&pos))
+ vy_mem_tree_iterator_prev(&itr->mem->tree, &pos);
+ if (vy_mem_tree_iterator_is_invalid(&pos))
return rc;
struct vy_tuple *t =
- *vy_mem_tree_itr_get_elem(&itr->mem->tree, &pos);
+ *vy_mem_tree_iterator_get_elem(&itr->mem->tree, &pos);
int cmp = vy_tuple_compare(t->data, itr->curr_tuple->data, itr->mem->key_def);
assert(cmp <= 0);
if (cmp < 0 || t->lsn >= break_lsn)
@@ -7838,11 +7839,11 @@ vy_mem_iterator_restore(struct vy_mem_iterator *itr,
return rc;
pos = itr->curr_pos;
while (true) {
- vy_mem_tree_itr_next(&itr->mem->tree, &pos);
- if (vy_mem_tree_itr_is_invalid(&pos))
+ vy_mem_tree_iterator_next(&itr->mem->tree, &pos);
+ if (vy_mem_tree_iterator_is_invalid(&pos))
return rc;
struct vy_tuple *t =
- *vy_mem_tree_itr_get_elem(&itr->mem->tree, &pos);
+ *vy_mem_tree_iterator_get_elem(&itr->mem->tree, &pos);
int cmp = vy_tuple_compare(t->data, last_tuple->data, itr->mem->key_def);
if (cmp > 0)
return rc;
@@ -8417,7 +8418,7 @@ vy_txw_iterator_iface_open(struct vy_tuple_iterator *vitr,
*/
struct vy_merge_src {
/* Source iterator */
- struct vy_tuple_iterator itr;
+ struct vy_tuple_iterator iterator;
/* Source can change during merge iteration */
bool is_mutable;
/* Source belongs to a range (see vy_merge_iterator comments) */
@@ -8523,7 +8524,7 @@ vy_merge_iterator_close(struct vy_merge_iterator *itr)
itr->curr_tuple = NULL;
}
for (size_t i = 0; i < itr->src_count; i++)
- itr->src[i].itr.iface->close(&itr->src[i].itr);
+ itr->src[i].iterator.iface->close(&itr->src[i].iterator);
free(itr->src);
itr->src_count = 0;
itr->src_capacity = 0;
@@ -8580,7 +8581,7 @@ vy_merge_iterator_add(struct vy_merge_iterator *itr,
struct vy_merge_src *src = &itr->src[itr->src_count++];
src->is_mutable = is_mutable;
src->belong_range = belong_range;
- return &src->itr;
+ return &src->iterator;
}
/**
@@ -8595,7 +8596,7 @@ vy_merge_iterator_propagate(struct vy_merge_iterator *itr)
for (uint32_t i = 0; i < itr->src_count; i++) {
if (itr->src[i].front_id != itr->front_id)
continue;
- if (itr->src[i].itr.iface->next_key(&itr->src[i].itr) < 0)
+ if (itr->src[i].iterator.iface->next_key(&itr->src[i].iterator) < 0)
return -1;
}
itr->front_id++;
@@ -8622,7 +8623,7 @@ vy_merge_iterator_locate_uniq_opt(struct vy_merge_iterator *itr)
min_tuple = NULL;
itr->curr_src = UINT32_MAX;
for (uint32_t i = 0; i < itr->src_count; i++) {
- struct vy_tuple_iterator *sub_itr = &itr->src[i].itr;
+ struct vy_tuple_iterator *sub_itr = &itr->src[i].iterator;
struct vy_tuple *t;
int rc = sub_itr->iface->get(sub_itr, &t);
if (rc > 0)
@@ -8649,7 +8650,7 @@ vy_merge_iterator_locate_uniq_opt(struct vy_merge_iterator *itr)
}
bool must_restart = false;
for (uint32_t i = itr->mutable_start; i < itr->mutable_end; i++) {
- struct vy_tuple_iterator *sub_itr = &itr->src[i].itr;
+ struct vy_tuple_iterator *sub_itr = &itr->src[i].iterator;
int rc = sub_itr->iface->restore(sub_itr, NULL);
if (rc < 0)
return rc;
@@ -8690,7 +8691,7 @@ vy_merge_iterator_locate(struct vy_merge_iterator *itr)
int order = (itr->order == VINYL_LE || itr->order == VINYL_LT ?
-1 : 1);
for (uint32_t i = itr->src_count; i--;) {
- struct vy_tuple_iterator *sub_itr = &itr->src[i].itr;
+ struct vy_tuple_iterator *sub_itr = &itr->src[i].iterator;
if (itr->src[i].is_mutable)
sub_itr->iface->restore(sub_itr, itr->curr_tuple);
struct vy_tuple *t;
@@ -8768,7 +8769,7 @@ vy_merge_iterator_next_lsn(struct vy_merge_iterator *itr)
return -1;
if (itr->curr_src == UINT32_MAX)
return 1;
- struct vy_tuple_iterator *sub_itr = &itr->src[itr->curr_src].itr;
+ struct vy_tuple_iterator *sub_itr = &itr->src[itr->curr_src].iterator;
int rc = sub_itr->iface->next_lsn(sub_itr);
if (rc < 0) {
return rc;
@@ -8782,7 +8783,7 @@ vy_merge_iterator_next_lsn(struct vy_merge_iterator *itr)
}
for (uint32_t i = itr->curr_src + 1; i < itr->src_count; i++) {
if (itr->is_in_uniq_opt) {
- sub_itr = &itr->src[i].itr;
+ sub_itr = &itr->src[i].iterator;
struct vy_tuple *t;
rc = sub_itr->iface->get(sub_itr, &t);
if (rc < 0)
@@ -8800,7 +8801,7 @@ vy_merge_iterator_next_lsn(struct vy_merge_iterator *itr)
}
} else if (itr->src[i].front_id == itr->front_id) {
- sub_itr = &itr->src[i].itr;
+ sub_itr = &itr->src[i].iterator;
itr->curr_src = i;
if (itr->curr_tuple != NULL)
vy_tuple_unref(itr->curr_tuple);
@@ -8822,7 +8823,7 @@ vy_merge_iterator_restore(struct vy_merge_iterator *itr,
{
int result = 0;
for (uint32_t i = 0; i < itr->src_count; i++) {
- struct vy_tuple_iterator *sub_itr = &itr->src[i].itr;
+ struct vy_tuple_iterator *sub_itr = &itr->src[i].iterator;
int rc = sub_itr->iface->restore(sub_itr, last_tuple);
if (rc < 0)
return rc;
@@ -8855,11 +8856,11 @@ struct vy_read_iterator {
int64_t vlsn;
/* iterator over ranges */
- struct vy_rangeiter range_itr;
+ struct vy_rangeiter range_iterator;
/* current range */
struct vy_range *curr_range;
/* merge iterator over current range */
- struct vy_merge_iterator merge_itr;
+ struct vy_merge_iterator merge_iterator;
struct vy_tuple *curr_tuple;
@@ -8909,7 +8910,7 @@ vy_read_iterator_use_range(struct vy_read_iterator *itr)
{
if (itr->tx != NULL) {
struct vy_tuple_iterator *sub_itr = vy_merge_iterator_add(
- &itr->merge_itr, true, false);
+ &itr->merge_iterator, true, false);
vy_txw_iterator_iface_open(sub_itr, itr->index, itr->tx,
itr->order, itr->key);
sub_itr->iface->restore(sub_itr, itr->curr_tuple);
@@ -8922,7 +8923,7 @@ vy_read_iterator_use_range(struct vy_read_iterator *itr)
/* only the newest range is mutable */
bool is_mutable = (mem == itr->curr_range->mem);
struct vy_tuple_iterator *sub_itr = vy_merge_iterator_add(
- &itr->merge_itr, is_mutable, true);
+ &itr->merge_iterator, is_mutable, true);
vy_mem_iterator_iface_open(sub_itr, mem, itr->order, itr->key,
itr->vlsn);
}
@@ -8931,7 +8932,7 @@ vy_read_iterator_use_range(struct vy_read_iterator *itr)
struct vy_filterif *compression = itr->index->compression_if;
while (run != NULL) {
struct vy_tuple_iterator *sub_itr = vy_merge_iterator_add(
- &itr->merge_itr, false, true);
+ &itr->merge_iterator, false, true);
vy_run_iterator_iface_open(sub_itr, itr->index, run,
itr->curr_range->fd, compression,
itr->order, itr->key, itr->vlsn);
@@ -8955,10 +8956,10 @@ vy_read_iterator_open(struct vy_read_iterator *itr,
itr->vlsn = vlsn;
itr->curr_tuple = NULL;
- vy_rangeiter_open(&itr->range_itr, index,
+ vy_rangeiter_open(&itr->range_iterator, index,
order == VINYL_EQ ? VINYL_GE : order, key, 0);
- itr->curr_range = vy_rangeiter_get(&itr->range_itr);
- vy_merge_iterator_open(&itr->merge_itr, index->key_def, order, key);
+ itr->curr_range = vy_rangeiter_get(&itr->range_iterator);
+ vy_merge_iterator_open(&itr->merge_iterator, index->key_def, order, key);
vy_read_iterator_use_range(itr);
itr->range_index_version = index->range_index_version;
}
@@ -8973,11 +8974,11 @@ int
vy_read_iterator_next_range(struct vy_read_iterator *itr)
{
assert(itr->curr_range != NULL);
- vy_merge_iterator_close(&itr->merge_itr);
- vy_merge_iterator_open(&itr->merge_itr, itr->index->key_def,
+ vy_merge_iterator_close(&itr->merge_iterator);
+ vy_merge_iterator_open(&itr->merge_iterator, itr->index->key_def,
itr->order, itr->key);
- vy_rangeiter_next(&itr->range_itr);
- itr->curr_range = vy_rangeiter_get(&itr->range_itr);
+ vy_rangeiter_next(&itr->range_iterator);
+ itr->curr_range = vy_rangeiter_get(&itr->range_iterator);
if (itr->curr_range != NULL && itr->order == VINYL_EQ) {
struct vy_page_info *min = vy_run_index_first_page(
&itr->curr_range->run->index);
@@ -8989,8 +8990,8 @@ vy_read_iterator_next_range(struct vy_read_iterator *itr)
}
vy_read_iterator_use_range(itr);
struct vy_tuple *tuple = NULL;
- int rc = vy_merge_iterator_get(&itr->merge_itr, &tuple);
- if (rc >= 0 && itr->merge_itr.range_ended && itr->curr_range != NULL)
+ int rc = vy_merge_iterator_get(&itr->merge_iterator, &tuple);
+ if (rc >= 0 && itr->merge_iterator.range_ended && itr->curr_range != NULL)
return vy_read_iterator_next_range(itr);
if (itr->curr_tuple != NULL)
vy_tuple_unref(itr->curr_tuple);
@@ -9014,8 +9015,8 @@ vy_read_iterator_check_versions(struct vy_read_iterator *itr)
itr->curr_tuple->data : itr->key;
enum vy_order order =
itr->order == VINYL_EQ ? VINYL_GE : itr->order;
- vy_rangeiter_open(&itr->range_itr, itr->index, order, key, 0);
- struct vy_range *range = vy_rangeiter_get(&itr->range_itr);
+ vy_rangeiter_open(&itr->range_iterator, itr->index, order, key, 0);
+ struct vy_range *range = vy_rangeiter_get(&itr->range_iterator);
if (range != itr->curr_range) {
itr->range_version =
range == NULL ? 1 : range->range_version + 1;
@@ -9026,11 +9027,11 @@ vy_read_iterator_check_versions(struct vy_read_iterator *itr)
itr->curr_range == NULL ? 0 : itr->curr_range->range_version;
if (itr->range_version != range_version) {
itr->range_version = range_version;
- vy_merge_iterator_close(&itr->merge_itr);
- vy_merge_iterator_open(&itr->merge_itr, itr->index->key_def,
+ vy_merge_iterator_close(&itr->merge_iterator);
+ vy_merge_iterator_open(&itr->merge_iterator, itr->index->key_def,
itr->order, itr->key);
vy_read_iterator_use_range(itr);
- vy_merge_iterator_restore(&itr->merge_itr, itr->curr_tuple);
+ vy_merge_iterator_restore(&itr->merge_iterator, itr->curr_tuple);
}
}
@@ -9044,8 +9045,8 @@ int
vy_read_iterator_next(struct vy_read_iterator *itr)
{
vy_read_iterator_check_versions(itr);
- int rc = vy_merge_iterator_next_key(&itr->merge_itr);
- if (rc >= 0 && itr->merge_itr.range_ended && itr->curr_range != NULL)
+ int rc = vy_merge_iterator_next_key(&itr->merge_iterator);
+ if (rc >= 0 && itr->merge_iterator.range_ended && itr->curr_range != NULL)
rc = vy_read_iterator_next_range(itr);
return rc;
@@ -9064,11 +9065,11 @@ vy_read_iterator_get(struct vy_read_iterator *itr, struct vy_tuple **result)
int rc;
while (true) {
struct vy_tuple *t;
- rc = vy_merge_iterator_get(&itr->merge_itr, &t);
- if (rc >= 0 && itr->merge_itr.range_ended && itr->curr_range != NULL) {
+ rc = vy_merge_iterator_get(&itr->merge_iterator, &t);
+ if (rc >= 0 && itr->merge_iterator.range_ended && itr->curr_range != NULL) {
rc = vy_read_iterator_next_range(itr);
if (rc == 0)
- vy_merge_iterator_get(&itr->merge_itr, &t);
+ vy_merge_iterator_get(&itr->merge_iterator, &t);
}
if (rc != 0) {
return rc;
@@ -9078,13 +9079,13 @@ vy_read_iterator_get(struct vy_read_iterator *itr, struct vy_tuple **result)
itr->curr_tuple = t;
vy_tuple_ref(itr->curr_tuple);
while (itr->curr_tuple->flags & SVUPSERT) {
- int rc = vy_merge_iterator_next_lsn(&itr->merge_itr);
+ int rc = vy_merge_iterator_next_lsn(&itr->merge_iterator);
if (rc < 0) {
return rc;
}
struct vy_tuple *next = NULL;
if (rc == 0)
- vy_merge_iterator_get(&itr->merge_itr, &next);
+ vy_merge_iterator_get(&itr->merge_iterator, &next);
struct vy_tuple *applied =
vy_apply_upsert(itr->curr_tuple, next,
itr->index, true);
@@ -9113,7 +9114,7 @@ vy_read_iterator_close(struct vy_read_iterator *itr)
if (itr->curr_tuple != NULL)
vy_tuple_unref(itr->curr_tuple);
itr->curr_tuple = NULL;
- vy_merge_iterator_close(&itr->merge_itr);
+ vy_merge_iterator_close(&itr->merge_iterator);
}
/* }}} Iterator over index */
diff --git a/src/lib/salad/bps_tree.h b/src/lib/salad/bps_tree.h
index f8f1bc5f899d5643eb4f6f1ef870754676dcac1d..cbd44d539c6f54d18a47f78b5b25751a3cef6542 100644
--- a/src/lib/salad/bps_tree.h
+++ b/src/lib/salad/bps_tree.h
@@ -146,17 +146,17 @@
* int bps_tree_debug_check_internal_functions(assert_on_error);
* // iterators:
* struct bps_tree_iterator bps_tree_invalid_iterator();
- * bool bps_tree_itr_is_invalid(itr);
- * bool bps_tree_itr_are_equal(tree, itr1, itr2);
- * struct bps_tree_iterator bps_tree_itr_first(tree);
- * struct bps_tree_iterator bps_tree_itr_last(tree);
+ * bool bps_tree_iterator_is_invalid(itr);
+ * bool bps_tree_iterator_are_equal(tree, itr1, itr2);
+ * struct bps_tree_iterator bps_tree_iterator_first(tree);
+ * struct bps_tree_iterator bps_tree_iterator_last(tree);
* struct bps_tree_iterator bps_tree_lower_bound(tree, key, exact);
* struct bps_tree_iterator bps_tree_upper_bound(tree, key, exact);
- * bps_tree_elem_t *bps_tree_itr_get_elem(tree, itr);
- * bool bps_tree_itr_next(tree, itr);
- * bool bps_tree_itr_prev(tree, itr);
- * void bps_tree_itr_freeze(tree, itr);
- * void bps_tree_itr_destroy(tree, itr);
+ * bps_tree_elem_t *bps_tree_iterator_get_elem(tree, itr);
+ * bool bps_tree_iterator_next(tree, itr);
+ * bool bps_tree_iterator_prev(tree, itr);
+ * void bps_tree_iterator_freeze(tree, itr);
+ * void bps_tree_iterator_destroy(tree, itr);
*/
/* }}} */
@@ -349,17 +349,17 @@ typedef uint32_t bps_tree_block_id_t;
#define bps_tree_mem_used _api_name(mem_used)
#define bps_tree_random _api_name(random)
#define bps_tree_invalid_iterator _api_name(invalid_iterator)
-#define bps_tree_itr_is_invalid _api_name(itr_is_invalid)
-#define bps_tree_itr_are_equal _api_name(itr_are_equal)
-#define bps_tree_itr_first _api_name(itr_first)
-#define bps_tree_itr_last _api_name(itr_last)
+#define bps_tree_iterator_is_invalid _api_name(iterator_is_invalid)
+#define bps_tree_iterator_are_equal _api_name(iterator_are_equal)
+#define bps_tree_iterator_first _api_name(iterator_first)
+#define bps_tree_iterator_last _api_name(iterator_last)
#define bps_tree_lower_bound _api_name(lower_bound)
#define bps_tree_upper_bound _api_name(upper_bound)
-#define bps_tree_itr_get_elem _api_name(itr_get_elem)
-#define bps_tree_itr_next _api_name(itr_next)
-#define bps_tree_itr_prev _api_name(itr_prev)
-#define bps_tree_itr_freeze _api_name(itr_freeze)
-#define bps_tree_itr_destroy _api_name(itr_destroy)
+#define bps_tree_iterator_get_elem _api_name(iterator_get_elem)
+#define bps_tree_iterator_next _api_name(iterator_next)
+#define bps_tree_iterator_prev _api_name(iterator_prev)
+#define bps_tree_iterator_freeze _api_name(iterator_freeze)
+#define bps_tree_iterator_destroy _api_name(iterator_destroy)
#define bps_tree_debug_check _api_name(debug_check)
#define bps_tree_print _api_name(print)
#define bps_tree_debug_check_internal_functions \
@@ -650,7 +650,7 @@ bps_tree_invalid_iterator();
* @return - true if iterator is invalid, false otherwise
*/
bool
-bps_tree_itr_is_invalid(struct bps_tree_iterator *itr);
+bps_tree_iterator_is_invalid(struct bps_tree_iterator *itr);
/**
* @brief Compare two iterators and return true if trey points to same element.
@@ -662,9 +662,9 @@ bps_tree_itr_is_invalid(struct bps_tree_iterator *itr);
* @return - true if iterators are equal, false otherwise
*/
bool
-bps_tree_itr_are_equal(const struct bps_tree *tree,
- struct bps_tree_iterator *itr1,
- struct bps_tree_iterator *itr2);
+bps_tree_iterator_are_equal(const struct bps_tree *tree,
+ struct bps_tree_iterator *itr1,
+ struct bps_tree_iterator *itr2);
/**
* @brief Get an iterator to the first element of the tree
@@ -672,7 +672,7 @@ bps_tree_itr_are_equal(const struct bps_tree *tree,
* @return - First iterator. Could be invalid if the tree is empty.
*/
struct bps_tree_iterator
-bps_tree_itr_first(const struct bps_tree *tree);
+bps_tree_iterator_first(const struct bps_tree *tree);
/**
* @brief Get an iterator to the last element of the tree
@@ -680,7 +680,7 @@ bps_tree_itr_first(const struct bps_tree *tree);
* @return - Last iterator. Could be invalid if the tree is empty.
*/
struct bps_tree_iterator
-bps_tree_itr_last(const struct bps_tree *tree);
+bps_tree_iterator_last(const struct bps_tree *tree);
/**
* @brief Get an iterator to the first element that is greater or
@@ -718,8 +718,8 @@ bps_tree_upper_bound(const struct bps_tree *tree, bps_tree_key_t key,
* @return - Pointer to the element. Null for invalid iterator
*/
bps_tree_elem_t *
-bps_tree_itr_get_elem(const struct bps_tree *tree,
- struct bps_tree_iterator *itr);
+bps_tree_iterator_get_elem(const struct bps_tree *tree,
+ struct bps_tree_iterator *itr);
/**
* @brief Increments an iterator, makes it point to the next element
@@ -731,7 +731,7 @@ bps_tree_itr_get_elem(const struct bps_tree *tree,
* @return - true on success, false if a resulted iterator is set to invalid
*/
bool
-bps_tree_itr_next(const struct bps_tree *tree, struct bps_tree_iterator *itr);
+bps_tree_iterator_next(const struct bps_tree *tree, struct bps_tree_iterator *itr);
/**
* @brief Decrements an iterator, makes it point to the previous element
@@ -743,17 +743,17 @@ bps_tree_itr_next(const struct bps_tree *tree, struct bps_tree_iterator *itr);
* @return - true on success, false if a resulted iterator is set to invalid
*/
bool
-bps_tree_itr_prev(const struct bps_tree *tree, struct bps_tree_iterator *itr);
+bps_tree_iterator_prev(const struct bps_tree *tree, struct bps_tree_iterator *itr);
/**
* @brief Freezes tree state for given iterator. All following tree modification
* will not apply to that iterator iteration. That iterator should be destroyed
- * with a bps_tree_itr_destroy call after usage.
+ * with a bps_tree_iterator_destroy call after usage.
* @param tree - pointer to a tree
* @param itr - pointer to tree iterator
*/
void
-bps_tree_itr_freeze(struct bps_tree *tree, struct bps_tree_iterator *itr);
+bps_tree_iterator_freeze(struct bps_tree *tree, struct bps_tree_iterator *itr);
/**
* @brief Destroy an iterator that was frozen before. Useless for not frozen
@@ -762,7 +762,7 @@ bps_tree_itr_freeze(struct bps_tree *tree, struct bps_tree_iterator *itr);
* @param itr - pointer to tree iterator
*/
void
-bps_tree_itr_destroy(struct bps_tree *tree, struct bps_tree_iterator *itr);
+bps_tree_iterator_destroy(struct bps_tree *tree, struct bps_tree_iterator *itr);
/**
* @brief Debug self-checking. Returns bitmask of found errors (0
@@ -1400,7 +1400,7 @@ bps_tree_invalid_iterator()
* @return - true if iterator is invalid, false otherwise
*/
inline bool
-bps_tree_itr_is_invalid(struct bps_tree_iterator *itr)
+bps_tree_iterator_is_invalid(struct bps_tree_iterator *itr)
{
return itr->block_id == (bps_tree_block_id_t)(-1);
}
@@ -1468,13 +1468,13 @@ bps_tree_get_leaf_safe(const struct bps_tree *tree,
* @return - true if iterators are equal, false otherwise
*/
inline bool
-bps_tree_itr_are_equal(const struct bps_tree *tree,
- struct bps_tree_iterator *itr1,
- struct bps_tree_iterator *itr2)
+bps_tree_iterator_are_equal(const struct bps_tree *tree,
+ struct bps_tree_iterator *itr1,
+ struct bps_tree_iterator *itr2)
{
- if (bps_tree_itr_is_invalid(itr1) && bps_tree_itr_is_invalid(itr2))
+ if (bps_tree_iterator_is_invalid(itr1) && bps_tree_iterator_is_invalid(itr2))
return true;
- if (bps_tree_itr_is_invalid(itr1) || bps_tree_itr_is_invalid(itr2))
+ if (bps_tree_iterator_is_invalid(itr1) || bps_tree_iterator_is_invalid(itr2))
return false;
if (itr1->block_id == itr2->block_id && itr1->pos == itr2->pos)
return true;
@@ -1503,7 +1503,7 @@ bps_tree_itr_are_equal(const struct bps_tree *tree,
* @return - First iterator. Could be invalid if the tree is empty.
*/
inline struct bps_tree_iterator
-bps_tree_itr_first(const struct bps_tree *tree)
+bps_tree_iterator_first(const struct bps_tree *tree)
{
struct bps_tree_iterator itr;
itr.block_id = tree->first_id;
@@ -1518,7 +1518,7 @@ bps_tree_itr_first(const struct bps_tree *tree)
* @return - Last iterator. Could be invalid if the tree is empty.
*/
inline struct bps_tree_iterator
-bps_tree_itr_last(const struct bps_tree *tree)
+bps_tree_iterator_last(const struct bps_tree *tree)
{
struct bps_tree_iterator itr;
itr.block_id = tree->last_id;
@@ -1643,8 +1643,8 @@ bps_tree_upper_bound(const struct bps_tree *tree, bps_tree_key_t key,
* @return - Pointer to the element. Null for invalid iterator
*/
inline bps_tree_elem_t *
-bps_tree_itr_get_elem(const struct bps_tree *tree,
- struct bps_tree_iterator *itr)
+bps_tree_iterator_get_elem(const struct bps_tree *tree,
+ struct bps_tree_iterator *itr)
{
struct bps_leaf *leaf = bps_tree_get_leaf_safe(tree, itr);
if (!leaf)
@@ -1662,7 +1662,7 @@ bps_tree_itr_get_elem(const struct bps_tree *tree,
* @return - true on success, false if a resulted iterator is set to invalid
*/
inline bool
-bps_tree_itr_next(const struct bps_tree *tree, struct bps_tree_iterator *itr)
+bps_tree_iterator_next(const struct bps_tree *tree, struct bps_tree_iterator *itr)
{
if (itr->block_id == (bps_tree_block_id_t)(-1)) {
if (matras_is_read_view_created(&itr->view))
@@ -1693,7 +1693,7 @@ bps_tree_itr_next(const struct bps_tree *tree, struct bps_tree_iterator *itr)
* @return - true on success, false if a resulted iterator is set to invalid
*/
inline bool
-bps_tree_itr_prev(const struct bps_tree *tree, struct bps_tree_iterator *itr)
+bps_tree_iterator_prev(const struct bps_tree *tree, struct bps_tree_iterator *itr)
{
if (itr->block_id == (bps_tree_block_id_t)(-1)) {
if (matras_is_read_view_created(&itr->view))
@@ -1718,12 +1718,12 @@ bps_tree_itr_prev(const struct bps_tree *tree, struct bps_tree_iterator *itr)
/**
* @brief Freezes tree state for given iterator. All following tree modification
* will not apply to that iterator iteration. That iterator should be destroyed
- * with a bps_tree_itr_destroy call after usage.
+ * with a bps_tree_iterator_destroy call after usage.
* @param tree - pointer to a tree
* @param itr - pointer to tree iterator
*/
inline void
-bps_tree_itr_freeze(struct bps_tree *tree, struct bps_tree_iterator *itr)
+bps_tree_iterator_freeze(struct bps_tree *tree, struct bps_tree_iterator *itr)
{
assert(!matras_is_read_view_created(&itr->view));
matras_create_read_view(&tree->matras, &itr->view);
@@ -1736,7 +1736,7 @@ bps_tree_itr_freeze(struct bps_tree *tree, struct bps_tree_iterator *itr)
* @param itr - pointer to tree iterator
*/
inline void
-bps_tree_itr_destroy(struct bps_tree *tree, struct bps_tree_iterator *itr)
+bps_tree_iterator_destroy(struct bps_tree *tree, struct bps_tree_iterator *itr)
{
matras_destroy_read_view(&tree->matras, &itr->view);
}
@@ -5604,17 +5604,17 @@ bps_tree_debug_check_internal_functions(bool assertme)
#undef bps_tree_mem_used
#undef bps_tree_random
#undef bps_tree_invalid_iterator
-#undef bps_tree_itr_is_invalid
-#undef bps_tree_itr_are_equal
-#undef bps_tree_itr_first
-#undef bps_tree_itr_last
+#undef bps_tree_iterator_is_invalid
+#undef bps_tree_iterator_are_equal
+#undef bps_tree_iterator_first
+#undef bps_tree_iterator_last
#undef bps_tree_lower_bound
#undef bps_tree_upper_bound
-#undef bps_tree_itr_get_elem
-#undef bps_tree_itr_next
-#undef bps_tree_itr_prev
-#undef bps_tree_itr_freeze
-#undef bps_tree_itr_destroy
+#undef bps_tree_iterator_get_elem
+#undef bps_tree_iterator_next
+#undef bps_tree_iterator_prev
+#undef bps_tree_iterator_freeze
+#undef bps_tree_iterator_destroy
#undef bps_tree_debug_check
#undef bps_tree_print
#undef bps_tree_debug_check_internal_functions
diff --git a/src/lib/salad/light.h b/src/lib/salad/light.h
index 0e6f1b03ff059cb879bc96146e3657765a8c530a..b297655683d078fcc1208c77af140dd91a3379ce 100644
--- a/src/lib/salad/light.h
+++ b/src/lib/salad/light.h
@@ -281,7 +281,7 @@ LIGHT(pos_valid)(struct LIGHT(core) *ht, uint32_t slotpos);
* @param itr - iterator to set
*/
void
-LIGHT(itr_begin)(const struct LIGHT(core) *ht, struct LIGHT(iterator) *itr);
+LIGHT(iterator_begin)(const struct LIGHT(core) *ht, struct LIGHT(iterator) *itr);
/**
* @brief Set iterator to position determined by key
@@ -291,8 +291,8 @@ LIGHT(itr_begin)(const struct LIGHT(core) *ht, struct LIGHT(iterator) *itr);
* @param data - key to find
*/
void
-LIGHT(itr_key)(const struct LIGHT(core) *ht, struct LIGHT(iterator) *itr,
- uint32_t hash, LIGHT_KEY_TYPE data);
+LIGHT(iterator_key)(const struct LIGHT(core) *ht, struct LIGHT(iterator) *itr,
+ uint32_t hash, LIGHT_KEY_TYPE data);
/**
* @brief Get the value that iterator currently points to
@@ -301,18 +301,18 @@ LIGHT(itr_key)(const struct LIGHT(core) *ht, struct LIGHT(iterator) *itr,
* @return poiner to the value or NULL if iteration is complete
*/
LIGHT_DATA_TYPE *
-LIGHT(itr_get_and_next)(const struct LIGHT(core) *ht,
- struct LIGHT(iterator) *itr);
+LIGHT(iterator_get_and_next)(const struct LIGHT(core) *ht,
+ struct LIGHT(iterator) *itr);
/**
* @brief Freezes state for given iterator. All following hash table modification
* will not apply to that iterator iteration. That iterator should be destroyed
- * with a light_itr_destroy call after usage.
+ * with a light_iterator_destroy call after usage.
* @param ht - pointer to a hash table struct
* @param itr - iterator to freeze
*/
void
-LIGHT(itr_freeze)(struct LIGHT(core) *ht, struct LIGHT(iterator) *itr);
+LIGHT(iterator_freeze)(struct LIGHT(core) *ht, struct LIGHT(iterator) *itr);
/**
* @brief Destroy an iterator that was frozen before. Useless for not frozen
@@ -321,7 +321,7 @@ LIGHT(itr_freeze)(struct LIGHT(core) *ht, struct LIGHT(iterator) *itr);
* @param itr - iterator to destroy
*/
void
-LIGHT(itr_destroy)(struct LIGHT(core) *ht, struct LIGHT(iterator) *itr);
+LIGHT(iterator_destroy)(struct LIGHT(core) *ht, struct LIGHT(iterator) *itr);
/* Functions definition */
@@ -972,7 +972,7 @@ LIGHT(pos_valid)(LIGHT(core) *ht, uint32_t slotpos)
* @param itr - iterator to set
*/
inline void
-LIGHT(itr_begin)(const struct LIGHT(core) *ht, struct LIGHT(iterator) *itr)
+LIGHT(iterator_begin)(const struct LIGHT(core) *ht, struct LIGHT(iterator) *itr)
{
(void)ht;
itr->slotpos = 0;
@@ -987,7 +987,7 @@ LIGHT(itr_begin)(const struct LIGHT(core) *ht, struct LIGHT(iterator) *itr)
* @param data - key to find
*/
inline void
-LIGHT(itr_key)(const struct LIGHT(core) *ht, struct LIGHT(iterator) *itr,
+LIGHT(iterator_key)(const struct LIGHT(core) *ht, struct LIGHT(iterator) *itr,
uint32_t hash, LIGHT_KEY_TYPE data)
{
itr->slotpos = LIGHT(find_key)(ht, hash, data);
@@ -1001,8 +1001,8 @@ LIGHT(itr_key)(const struct LIGHT(core) *ht, struct LIGHT(iterator) *itr,
* @return poiner to the value or NULL if iteration is complete
*/
inline LIGHT_DATA_TYPE *
-LIGHT(itr_get_and_next)(const struct LIGHT(core) *ht,
- struct LIGHT(iterator) *itr)
+LIGHT(iterator_get_and_next)(const struct LIGHT(core) *ht,
+ struct LIGHT(iterator) *itr)
{
const struct matras_view *view;
view = matras_is_read_view_created(&itr->view) ?
@@ -1021,12 +1021,12 @@ LIGHT(itr_get_and_next)(const struct LIGHT(core) *ht,
/**
* @brief Freezes state for given iterator. All following hash table modification
* will not apply to that iterator iteration. That iterator should be destroyed
- * with a light_itr_destroy call after usage.
+ * with a light_iterator_destroy call after usage.
* @param ht - pointer to a hash table struct
* @param itr - iterator to freeze
*/
inline void
-LIGHT(itr_freeze)(struct LIGHT(core) *ht, struct LIGHT(iterator) *itr)
+LIGHT(iterator_freeze)(struct LIGHT(core) *ht, struct LIGHT(iterator) *itr)
{
assert(!matras_is_read_view_created(&itr->view));
matras_create_read_view(&ht->mtable, &itr->view);
@@ -1039,7 +1039,7 @@ LIGHT(itr_freeze)(struct LIGHT(core) *ht, struct LIGHT(iterator) *itr)
* @param itr - iterator to destroy
*/
inline void
-LIGHT(itr_destroy)(struct LIGHT(core) *ht, struct LIGHT(iterator) *itr)
+LIGHT(iterator_destroy)(struct LIGHT(core) *ht, struct LIGHT(iterator) *itr)
{
matras_destroy_read_view(&ht->mtable, &itr->view);
}
diff --git a/test/unit/CMakeLists.txt b/test/unit/CMakeLists.txt
index a1dffec5925aed3ff0e89b79f7bd938fd1aaf9d3..d8f67997cac6d7e0029f2b879d25716f9f09651b 100644
--- a/test/unit/CMakeLists.txt
+++ b/test/unit/CMakeLists.txt
@@ -39,12 +39,12 @@ target_link_libraries(uuid.test bit)
add_executable(bps_tree.test bps_tree.cc)
target_link_libraries(bps_tree.test small misc)
-add_executable(bps_tree_itr.test bps_tree_itr.cc)
-target_link_libraries(bps_tree_itr.test small misc)
+add_executable(bps_tree_iterator.test bps_tree_iterator.cc)
+target_link_libraries(bps_tree_iterator.test small misc)
add_executable(rtree.test rtree.cc)
target_link_libraries(rtree.test salad small)
-add_executable(rtree_itr.test rtree_itr.cc)
-target_link_libraries(rtree_itr.test salad small)
+add_executable(rtree_iterator.test rtree_iterator.cc)
+target_link_libraries(rtree_iterator.test salad small)
add_executable(rtree_multidim.test rtree_multidim.cc)
target_link_libraries(rtree_multidim.test salad small)
add_executable(light.test light.cc)
diff --git a/test/unit/bps_tree.cc b/test/unit/bps_tree.cc
index 9951c6b3ce1c07f9fb0b6d390fb7a1ab1ec9ef43..879a71096e84525957930ffbbb2d7a686ab89f24 100644
--- a/test/unit/bps_tree.cc
+++ b/test/unit/bps_tree.cc
@@ -207,12 +207,12 @@ check_trees_are_identical(test *tree, sptree_test *spt_test)
if (test_size(tree) != spt_test->size)
return false;
int n = test_size(tree);
- test_iterator itr = test_itr_first(tree);
+ test_iterator iterator = test_iterator_first(tree);
sptree_test_iterator *spitr = sptree_test_iterator_init(spt_test);
for (int i = 0; i < n; i++) {
- type_t v1 = *test_itr_get_elem(tree, &itr);
+ type_t v1 = *test_iterator_get_elem(tree, &iterator);
type_t v2 = *(type_t *)sptree_test_iterator_next(spitr);
- test_itr_next(tree, &itr);
+ test_iterator_next(tree, &iterator);
if (v1 != v2) {
sptree_test_iterator_free(spitr);
return false;
@@ -527,15 +527,15 @@ loading_test()
if (test_debug_check(&tree))
fail("debug check nonzero", "true");
- struct test_iterator itr;
- itr = test_itr_first(&tree);
+ struct test_iterator iterator;
+ iterator = test_iterator_first(&tree);
for (type_t j = 0; j < i; j++) {
- type_t *v = test_itr_get_elem(&tree, &itr);
+ type_t *v = test_iterator_get_elem(&tree, &iterator);
if (!v || *v != j)
fail("wrong build result", "true");
- test_itr_next(&tree, &itr);
+ test_iterator_next(&tree, &iterator);
}
- if (!test_itr_is_invalid(&itr))
+ if (!test_iterator_is_invalid(&iterator))
fail("wrong build result", "true");
test_destroy(&tree);
diff --git a/test/unit/bps_tree_itr.cc b/test/unit/bps_tree_iterator.cc
similarity index 75%
rename from test/unit/bps_tree_itr.cc
rename to test/unit/bps_tree_iterator.cc
index 035e1daf4d42f7de183cce3189bb5799b917f1f6..eeb91d7e298f8b07d9feccefb23c05e5c9bcff0e 100644
--- a/test/unit/bps_tree_itr.cc
+++ b/test/unit/bps_tree_iterator.cc
@@ -56,7 +56,7 @@ extent_free(void *extent)
}
static void
-itr_check()
+iterator_check()
{
header();
@@ -68,9 +68,9 @@ itr_check()
test_iterator tmp1, tmp2;
tmp1 = test_invalid_iterator();
tmp2 = test_invalid_iterator();
- if (!test_itr_is_invalid(&tmp1))
+ if (!test_iterator_is_invalid(&tmp1))
fail("invalid iterator is not invalid", "true");
- if (!test_itr_are_equal(&tree, &tmp1, &tmp2))
+ if (!test_iterator_are_equal(&tree, &tmp1, &tmp2))
fail("invalid iterators are not equal", "true");
}
@@ -100,41 +100,41 @@ itr_check()
/* Print first 7 elems */
{
printf("--> ");
- test_iterator itr = test_itr_first(&tree);
+ test_iterator iterator = test_iterator_first(&tree);
for (int i = 0; i < 7; i++) {
- elem_t *elem = test_itr_get_elem(&tree, &itr);
+ elem_t *elem = test_iterator_get_elem(&tree, &iterator);
printf("(%ld,%ld) ", elem->first, elem->second);
- test_itr_next(&tree, &itr);
+ test_iterator_next(&tree, &iterator);
}
printf("\n");
}
/* Print last 7 elems */
{
printf("<-- ");
- test_iterator itr = test_itr_last(&tree);
+ test_iterator iterator = test_iterator_last(&tree);
for (int i = 0; i < 7; i++) {
- elem_t *elem = test_itr_get_elem(&tree, &itr);
+ elem_t *elem = test_iterator_get_elem(&tree, &iterator);
printf("(%ld,%ld) ", elem->first, elem->second);
- test_itr_prev(&tree, &itr);
+ test_iterator_prev(&tree, &iterator);
}
printf("\n");
}
/* Iterate forward all elements 5 times */
{
- test_iterator itr = test_itr_first(&tree);
+ test_iterator iterator = test_iterator_first(&tree);
for (long i = 0; i < count1 * count2 * 5; i++) {
- elem_t *elem = test_itr_get_elem(&tree, &itr);
+ elem_t *elem = test_iterator_get_elem(&tree, &iterator);
if (elem->first != ((i % (count1 * count2)) / count2) * 2)
fail("iterate all failed (1)", "true");
if (elem->second != i % count2)
fail("iterate all failed (2)", "true");
- bool itr_res = test_itr_next(&tree, &itr);
- if (!!itr_res == !!test_itr_is_invalid(&itr))
+ bool iterator_res = test_iterator_next(&tree, &iterator);
+ if (!!iterator_res == !!test_iterator_is_invalid(&iterator))
fail("iterate all failed (3)", "true");
- if (!itr_res) {
- itr_res = test_itr_next(&tree, &itr);
- if (!itr_res || test_itr_is_invalid(&itr))
+ if (!iterator_res) {
+ iterator_res = test_iterator_next(&tree, &iterator);
+ if (!iterator_res || test_iterator_is_invalid(&iterator))
fail("iterate all failed (4)", "true");
}
}
@@ -142,20 +142,20 @@ itr_check()
/* Iterate backward all elements 5 times */
{
- test_iterator itr = test_itr_last(&tree);
+ test_iterator iterator = test_iterator_last(&tree);
for (long i = 0; i < count1 * count2 * 5; i++) {
- elem_t *elem = test_itr_get_elem(&tree, &itr);
+ elem_t *elem = test_iterator_get_elem(&tree, &iterator);
long j = count1 * count2 - 1 - (i % (count1 * count2));
if (elem->first != (j / count2) * 2)
fail("iterate all failed (5)", "true");
if (elem->second != j % count2)
fail("iterate all failed (6)", "true");
- bool itr_res = test_itr_prev(&tree, &itr);
- if (!!itr_res == !!test_itr_is_invalid(&itr))
+ bool iterator_res = test_iterator_prev(&tree, &iterator);
+ if (!!iterator_res == !!test_iterator_is_invalid(&iterator))
fail("iterate all failed (7)", "true");
- if (!itr_res) {
- itr_res = test_itr_prev(&tree, &itr);
- if (!itr_res || test_itr_is_invalid(&itr))
+ if (!iterator_res) {
+ iterator_res = test_iterator_prev(&tree, &iterator);
+ if (!iterator_res || test_iterator_is_invalid(&iterator))
fail("iterate all failed (8)", "true");
}
}
@@ -174,19 +174,19 @@ itr_check()
fail("Exact flag is broken", "true");
printf("Key %ld, %s range [%s, %s): ", key,
has_this_key1 ? "not empty" : "empty",
- test_itr_is_invalid(&begin) ? "eof" : "ptr",
- test_itr_is_invalid(&end) ? "eof" : "ptr");
+ test_iterator_is_invalid(&begin) ? "eof" : "ptr",
+ test_iterator_is_invalid(&end) ? "eof" : "ptr");
test_iterator runner = begin;
- while (!test_itr_are_equal(&tree, &runner, &end)) {
- elem_t *elem = test_itr_get_elem(&tree, &runner);
+ while (!test_iterator_are_equal(&tree, &runner, &end)) {
+ elem_t *elem = test_iterator_get_elem(&tree, &runner);
printf("(%ld,%ld) ", elem->first, elem->second);
- test_itr_next(&tree, &runner);
+ test_iterator_next(&tree, &runner);
}
printf(" <-> ");
runner = end;
- while (!test_itr_are_equal(&tree, &runner, &begin)) {
- test_itr_prev(&tree, &runner);
- elem_t *elem = test_itr_get_elem(&tree, &runner);
+ while (!test_iterator_are_equal(&tree, &runner, &begin)) {
+ test_iterator_prev(&tree, &runner);
+ elem_t *elem = test_iterator_get_elem(&tree, &runner);
printf("(%ld,%ld) ", elem->first, elem->second);
}
printf("\n");
@@ -198,20 +198,20 @@ itr_check()
test_iterator begin = test_lower_bound(&tree, i, 0);
test_iterator end = test_upper_bound(&tree, i, 0);
long real_count = 0;
- while (!test_itr_are_equal(&tree, &begin, &end)) {
- elem_t *elem = test_itr_get_elem(&tree, &begin);
+ while (!test_iterator_are_equal(&tree, &begin, &end)) {
+ elem_t *elem = test_iterator_get_elem(&tree, &begin);
if (elem->first != i)
- fail("range itr failed (1)", "true");
+ fail("range iterator failed (1)", "true");
if (elem->second != real_count)
- fail("range itr failed (2)", "true");
+ fail("range iterator failed (2)", "true");
real_count++;
- test_itr_next(&tree, &begin);
+ test_iterator_next(&tree, &begin);
}
long must_be_count = 0;
if (i >= 0 && i / 2 <= count1 - 1 && (i & 1) == 0)
must_be_count = count2;
if (real_count != must_be_count)
- fail("range itr failed (3)", "true");
+ fail("range iterator failed (3)", "true");
}
test_destroy(&tree);
@@ -220,7 +220,7 @@ itr_check()
}
static void
-itr_invalidate_check()
+iterator_invalidate_check()
{
header();
@@ -247,12 +247,12 @@ itr_invalidate_check()
e.second = i * test_size * 2;
test_insert(&tree, e, 0);
}
- iterators[0] = test_itr_first(&tree);
- assert(test_itr_get_elem(&tree, iterators));
+ iterators[0] = test_iterator_first(&tree);
+ assert(test_iterator_get_elem(&tree, iterators));
for (long i = 1; i < test_size; i++) {
iterators[i] = iterators[i - 1];
- test_itr_next(&tree, iterators + i);
- assert(test_itr_get_elem(&tree, iterators + i));
+ test_iterator_next(&tree, iterators + i);
+ assert(test_iterator_get_elem(&tree, iterators + i));
}
for (long i = del_pos; i < del_pos + del_cnt; i++) {
elem_t e;
@@ -263,7 +263,7 @@ itr_invalidate_check()
}
for (long i = 0; i < test_size; i++) {
do {
- elem_t *e = test_itr_get_elem(&tree, iterators + i);
+ elem_t *e = test_iterator_get_elem(&tree, iterators + i);
if (e) {
if (e->first != e->second)
fail("unexpected result of getting elem (1)", "true");
@@ -273,7 +273,7 @@ itr_invalidate_check()
if ( (v < 0 || v >= del_pos) && (v < del_pos + del_cnt || v >= test_size) )
fail("unexpected result of getting elem (3)", "true");
}
- } while(test_itr_next(&tree, iterators + i));
+ } while(test_iterator_next(&tree, iterators + i));
}
test_destroy(&tree);
}
@@ -291,12 +291,12 @@ itr_invalidate_check()
e.second = i * test_size * 2;
test_insert(&tree, e, 0);
}
- iterators[0] = test_itr_first(&tree);
- assert(test_itr_get_elem(&tree, iterators));
+ iterators [0] = test_iterator_first(&tree);
+ assert(test_iterator_get_elem(&tree, iterators));
for (long i = 1; i < test_size; i++) {
iterators[i] = iterators[i - 1];
- test_itr_next(&tree, iterators + i);
- assert(test_itr_get_elem(&tree, iterators + i));
+ test_iterator_next(&tree, iterators + i);
+ assert(test_iterator_get_elem(&tree, iterators + i));
}
for (long i = 0; i < ins_cnt; i++) {
elem_t e;
@@ -307,7 +307,7 @@ itr_invalidate_check()
}
for (long i = 0; i < test_size; i++) {
do {
- elem_t *e = test_itr_get_elem(&tree, iterators + i);
+ elem_t *e = test_iterator_get_elem(&tree, iterators + i);
if (e) {
if (e->first != e->second)
fail("unexpected result of getting elem (4)", "true");
@@ -324,7 +324,7 @@ itr_invalidate_check()
fail("unexpected result of getting elem (7)", "true");
}
}
- } while(test_itr_next(&tree, iterators + i));
+ } while(test_iterator_next(&tree, iterators + i));
}
test_destroy(&tree);
}
@@ -346,12 +346,12 @@ itr_invalidate_check()
e.second = i * test_size * 2;
test_insert(&tree, e, 0);
}
- iterators[0] = test_itr_first(&tree);
- assert(test_itr_get_elem(&tree, iterators));
+ iterators[0] = test_iterator_first(&tree);
+ assert(test_iterator_get_elem(&tree, iterators));
for (long i = 1; i < test_size; i++) {
iterators[i] = iterators[i - 1];
- test_itr_next(&tree, iterators + i);
- assert(test_itr_get_elem(&tree, iterators + i));
+ test_iterator_next(&tree, iterators + i);
+ assert(test_iterator_get_elem(&tree, iterators + i));
}
for (long i = del_pos; i < del_pos + del_cnt; i++) {
elem_t e;
@@ -369,7 +369,7 @@ itr_invalidate_check()
}
for (long i = 0; i < test_size; i++) {
do {
- elem_t *e = test_itr_get_elem(&tree, iterators + i);
+ elem_t *e = test_iterator_get_elem(&tree, iterators + i);
if (e) {
if (e->first != e->second)
fail("unexpected result of getting elem (8)", "true");
@@ -386,7 +386,7 @@ itr_invalidate_check()
fail("unexpected result of getting elem (b)", "true");
}
}
- } while(test_itr_next(&tree, iterators + i));
+ } while(test_iterator_next(&tree, iterators + i));
}
test_destroy(&tree);
}
@@ -395,7 +395,7 @@ itr_invalidate_check()
}
static void
-itr_freeze_check()
+iterator_freeze_check()
{
header();
@@ -420,16 +420,16 @@ itr_freeze_check()
fail_if(check);
assert(check == 0);
}
- struct test_iterator itr = test_itr_first(&tree);
+ struct test_iterator iterator = test_iterator_first(&tree);
elem_t *e;
- while ((e = test_itr_get_elem(&tree, &itr))) {
+ while ((e = test_iterator_get_elem(&tree, &iterator))) {
comp_buf1[comp_buf_size1++] = *e;
- test_itr_next(&tree, &itr);
+ test_iterator_next(&tree, &iterator);
}
- struct test_iterator itr1 = test_itr_first(&tree);
- test_itr_freeze(&tree, &itr1);
- struct test_iterator itr2 = test_itr_first(&tree);
- test_itr_freeze(&tree, &itr2);
+ struct test_iterator iterator1 = test_iterator_first(&tree);
+ test_iterator_freeze(&tree, &iterator1);
+ struct test_iterator iterator2 = test_iterator_first(&tree);
+ test_iterator_freeze(&tree, &iterator2);
for (int j = 0; j < test_data_size; j++) {
elem_t e;
e.first = rand() % test_data_mod;
@@ -440,7 +440,7 @@ itr_freeze_check()
assert(check == 0);
}
int tested_count = 0;
- while ((e = test_itr_get_elem(&tree, &itr1))) {
+ while ((e = test_iterator_get_elem(&tree, &iterator1))) {
if (*e != comp_buf1[tested_count]) {
fail("version restore failed (1)", "true");
}
@@ -448,9 +448,9 @@ itr_freeze_check()
if (tested_count > comp_buf_size1) {
fail("version restore failed (2)", "true");
}
- test_itr_next(&tree, &itr1);
+ test_iterator_next(&tree, &iterator1);
}
- test_itr_destroy(&tree, &itr1);
+ test_iterator_destroy(&tree, &iterator1);
for (int j = 0; j < test_data_size; j++) {
elem_t e;
e.first = rand() % test_data_mod;
@@ -462,7 +462,7 @@ itr_freeze_check()
}
tested_count = 0;
- while ((e = test_itr_get_elem(&tree, &itr2))) {
+ while ((e = test_iterator_get_elem(&tree, &iterator2))) {
if (*e != comp_buf1[tested_count]) {
fail("version restore failed (1)", "true");
}
@@ -470,7 +470,7 @@ itr_freeze_check()
if (tested_count > comp_buf_size1) {
fail("version restore failed (2)", "true");
}
- test_itr_next(&tree, &itr2);
+ test_iterator_next(&tree, &iterator2);
}
test_destroy(&tree);
@@ -484,9 +484,9 @@ int
main(void)
{
srand(time(0));
- itr_check();
- itr_invalidate_check();
- itr_freeze_check();
+ iterator_check();
+ iterator_invalidate_check();
+ iterator_freeze_check();
if (total_extents_allocated) {
fail("memory leak", "true");
}
diff --git a/test/unit/bps_tree_itr.result b/test/unit/bps_tree_iterator.result
similarity index 75%
rename from test/unit/bps_tree_itr.result
rename to test/unit/bps_tree_iterator.result
index 456db4428bc1927779856116ee82f168a1d1675b..b82801bd0983507c3056bada77aef35c6cdb257e 100644
--- a/test/unit/bps_tree_itr.result
+++ b/test/unit/bps_tree_iterator.result
@@ -1,4 +1,4 @@
- *** itr_check ***
+ *** iterator_check ***
Test tree size: 50000
--> (0,0) (0,1) (0,2) (0,3) (0,4) (2,0) (2,1)
<-- (19998,4) (19998,3) (19998,2) (19998,1) (19998,0) (19996,4) (19996,3)
@@ -8,8 +8,8 @@ Key 10, not empty range [ptr, ptr): (10,0) (10,1) (10,2) (10,3) (10,4) <-> (10,
Key 15, empty range [ptr, ptr): <->
Key 19998, not empty range [ptr, eof): (19998,0) (19998,1) (19998,2) (19998,3) (19998,4) <-> (19998,4) (19998,3) (19998,2) (19998,1) (19998,0)
Key 20000, empty range [eof, eof): <->
- *** itr_check: done ***
- *** itr_invalidate_check ***
- *** itr_invalidate_check: done ***
- *** itr_freeze_check ***
- *** itr_freeze_check: done ***
+ *** iterator_check: done ***
+ *** iterator_invalidate_check ***
+ *** iterator_invalidate_check: done ***
+ *** iterator_freeze_check ***
+ *** iterator_freeze_check: done ***
diff --git a/test/unit/light.cc b/test/unit/light.cc
index d459b7a7bc14e512e466e5f440d837c3c26eeea0..c72a920a407002b0aeaecc7ccbbf0208d0fe4267 100644
--- a/test/unit/light.cc
+++ b/test/unit/light.cc
@@ -182,7 +182,7 @@ collision_test()
}
static void
-itr_test()
+iterator_test()
{
header();
@@ -192,9 +192,9 @@ itr_test()
const size_t start_limits = 20;
const size_t iterator_count = 16;
- struct light_iterator itrs[iterator_count];
+ struct light_iterator iterators[iterator_count];
for (size_t i = 0; i < iterator_count; i++)
- light_itr_begin(&ht, itrs + i);
+ light_iterator_begin(&ht, iterators + i);
size_t cur_iterator = 0;
hash_value_t strage_thing = 0;
@@ -210,16 +210,16 @@ itr_test()
light_delete(&ht, fnd);
}
- hash_value_t *pval = light_itr_get_and_next(&ht, itrs + cur_iterator);
+ hash_value_t *pval = light_iterator_get_and_next(&ht, iterators + cur_iterator);
if (pval)
strage_thing ^= *pval;
if (!pval || (rand() % iterator_count) == 0) {
if (rand() % iterator_count) {
hash_value_t val = rand() % limits;
hash_t h = hash(val);
- light_itr_key(&ht, itrs + cur_iterator, h, val);
+ light_iterator_key(&ht, iterators + cur_iterator, h, val);
} else {
- light_itr_begin(&ht, itrs + cur_iterator);
+ light_iterator_begin(&ht, iterators + cur_iterator);
}
}
@@ -238,7 +238,7 @@ itr_test()
}
static void
-itr_freeze_check()
+iterator_freeze_check()
{
header();
@@ -257,25 +257,25 @@ itr_freeze_check()
hash_t h = hash(val);
light_insert(&ht, h, val);
}
- struct light_iterator itr;
- light_itr_begin(&ht, &itr);
+ struct light_iterator iterator;
+ light_iterator_begin(&ht, &iterator);
hash_value_t *e;
- while ((e = light_itr_get_and_next(&ht, &itr))) {
+ while ((e = light_iterator_get_and_next(&ht, &iterator))) {
comp_buf[comp_buf_size++] = *e;
}
- struct light_iterator itr1;
- light_itr_begin(&ht, &itr1);
- light_itr_freeze(&ht, &itr1);
- struct light_iterator itr2;
- light_itr_begin(&ht, &itr2);
- light_itr_freeze(&ht, &itr2);
+ struct light_iterator iterator1;
+ light_iterator_begin(&ht, &iterator1);
+ light_iterator_freeze(&ht, &iterator1);
+ struct light_iterator iterator2;
+ light_iterator_begin(&ht, &iterator2);
+ light_iterator_freeze(&ht, &iterator2);
for (int j = 0; j < test_data_size; j++) {
hash_value_t val = rand() % test_data_mod;
hash_t h = hash(val);
light_insert(&ht, h, val);
}
int tested_count = 0;
- while ((e = light_itr_get_and_next(&ht, &itr1))) {
+ while ((e = light_iterator_get_and_next(&ht, &iterator1))) {
if (*e != comp_buf[tested_count]) {
fail("version restore failed (1)", "true");
}
@@ -284,7 +284,7 @@ itr_freeze_check()
fail("version restore failed (2)", "true");
}
}
- light_itr_destroy(&ht, &itr1);
+ light_iterator_destroy(&ht, &iterator1);
for (int j = 0; j < test_data_size; j++) {
hash_value_t val = rand() % test_data_mod;
hash_t h = hash(val);
@@ -294,7 +294,7 @@ itr_freeze_check()
}
tested_count = 0;
- while ((e = light_itr_get_and_next(&ht, &itr2))) {
+ while ((e = light_iterator_get_and_next(&ht, &iterator2))) {
if (*e != comp_buf[tested_count]) {
fail("version restore failed (3)", "true");
}
@@ -316,8 +316,8 @@ main(int, const char**)
srand(time(0));
simple_test();
collision_test();
- itr_test();
- itr_freeze_check();
+ iterator_test();
+ iterator_freeze_check();
if (extents_count != 0)
fail("memory leak!", "true");
}
diff --git a/test/unit/light.result b/test/unit/light.result
index 91cc71454a80a0a33b54fd17822f219f80c57701..39c4d7c533f9453870ff3b7bdf00895f539e655f 100644
--- a/test/unit/light.result
+++ b/test/unit/light.result
@@ -2,7 +2,7 @@
*** simple_test: done ***
*** collision_test ***
*** collision_test: done ***
- *** itr_test ***
- *** itr_test: done ***
- *** itr_freeze_check ***
- *** itr_freeze_check: done ***
+ *** iterator_test ***
+ *** iterator_test: done ***
+ *** iterator_freeze_check ***
+ *** iterator_freeze_check: done ***
diff --git a/test/unit/rtree_itr.cc b/test/unit/rtree_iterator.cc
similarity index 98%
rename from test/unit/rtree_itr.cc
rename to test/unit/rtree_iterator.cc
index 3c6c3c3fdc1e7d46dc59a759da1a26b3fe9180c6..7e54a8d9cc3a69d1be796fa3b6fd5d3afcc055f2 100644
--- a/test/unit/rtree_itr.cc
+++ b/test/unit/rtree_iterator.cc
@@ -25,7 +25,7 @@ extent_free(void *page)
}
static void
-itr_check()
+iterator_check()
{
header();
@@ -192,7 +192,7 @@ itr_check()
}
static void
-itr_invalidate_check()
+iterator_invalidate_check()
{
header();
@@ -299,8 +299,8 @@ itr_invalidate_check()
int
main(void)
{
- itr_check();
- itr_invalidate_check();
+ iterator_check();
+ iterator_invalidate_check();
if (extent_count != 0) {
fail("memory leak!", "false");
}
diff --git a/test/unit/rtree_iterator.result b/test/unit/rtree_iterator.result
new file mode 100644
index 0000000000000000000000000000000000000000..5eac9f090ea9d96e8f383451c890687ead08e0c8
--- /dev/null
+++ b/test/unit/rtree_iterator.result
@@ -0,0 +1,7 @@
+ *** iterator_check ***
+Test tree size: 50000
+--> 0x1 0x2 0x3 0x4 0x5 0x6 0x7
+<-- 0xc34c 0xc34d 0xc34e 0xc34f 0xc350 0xc34b 0xc34a
+ *** iterator_check: done ***
+ *** iterator_invalidate_check ***
+ *** iterator_invalidate_check: done ***
diff --git a/test/unit/rtree_itr.result b/test/unit/rtree_itr.result
deleted file mode 100644
index acc94d0264cea2ea3deb63e3cd4ef4e17a85ef3b..0000000000000000000000000000000000000000
--- a/test/unit/rtree_itr.result
+++ /dev/null
@@ -1,7 +0,0 @@
- *** itr_check ***
-Test tree size: 50000
---> 0x1 0x2 0x3 0x4 0x5 0x6 0x7
-<-- 0xc34c 0xc34d 0xc34e 0xc34f 0xc350 0xc34b 0xc34a
- *** itr_check: done ***
- *** itr_invalidate_check ***
- *** itr_invalidate_check: done ***
diff --git a/test/wal_off/itr_lt_gt.result b/test/wal_off/iterator_lt_gt.result
similarity index 100%
rename from test/wal_off/itr_lt_gt.result
rename to test/wal_off/iterator_lt_gt.result
diff --git a/test/wal_off/itr_lt_gt.test.lua b/test/wal_off/iterator_lt_gt.test.lua
similarity index 100%
rename from test/wal_off/itr_lt_gt.test.lua
rename to test/wal_off/iterator_lt_gt.test.lua