Merge branch 'ps/reftable-reusable-iterator' into seen
Code clean-up to make the reftable iterator closer to be reusable.
* ps/reftable-reusable-iterator:
reftable/merged: adapt interface to allow reuse of iterators
reftable/stack: provide convenience functions to create iterators
reftable/reader: adapt interface to allow reuse of iterators
reftable/generic: adapt interface to allow reuse of iterators
reftable/generic: move seeking of records into the iterator
reftable/merged: simplify indices for subiterators
reftable/merged: split up initialization and seeking of records
reftable/reader: set up the reader when initializing table iterator
reftable/reader: inline `reader_seek_internal()`
reftable/reader: separate concerns of table iter and reftable reader
reftable/reader: unify indexed and linear seeking
reftable/reader: avoid copying index iterator
reftable/block: use `size_t` to track restart point index
diff --git a/refs/reftable-backend.c b/refs/reftable-backend.c
index b24eacd..7f57ae5 100644
--- a/refs/reftable-backend.c
+++ b/refs/reftable-backend.c
@@ -16,7 +16,6 @@
#include "../reftable/reftable-record.h"
#include "../reftable/reftable-error.h"
#include "../reftable/reftable-iterator.h"
-#include "../reftable/reftable-merged.h"
#include "../setup.h"
#include "../strmap.h"
#include "parse.h"
@@ -502,7 +501,6 @@
const char *prefix,
int flags)
{
- struct reftable_merged_table *merged_table;
struct reftable_ref_iterator *iter;
int ret;
@@ -522,9 +520,8 @@
if (ret)
goto done;
- merged_table = reftable_stack_merged_table(stack);
-
- ret = reftable_merged_table_seek_ref(merged_table, &iter->iter, prefix);
+ reftable_stack_init_ref_iterator(stack, &iter->iter);
+ ret = reftable_iterator_seek_ref(&iter->iter, prefix);
if (ret)
goto done;
@@ -1052,8 +1049,6 @@
static int write_transaction_table(struct reftable_writer *writer, void *cb_data)
{
struct write_transaction_table_arg *arg = cb_data;
- struct reftable_merged_table *mt =
- reftable_stack_merged_table(arg->stack);
uint64_t ts = reftable_stack_next_update_index(arg->stack);
struct reftable_log_record *logs = NULL;
struct ident_split committer_ident = {0};
@@ -1090,6 +1085,8 @@
struct reftable_log_record log = {0};
struct reftable_iterator it = {0};
+ reftable_stack_init_log_iterator(arg->stack, &it);
+
/*
* When deleting refs we also delete all reflog entries
* with them. While it is not strictly required to
@@ -1099,7 +1096,7 @@
* Unfortunately, we have no better way than to delete
* all reflog entries one by one.
*/
- ret = reftable_merged_table_seek_log(mt, &it, u->refname);
+ ret = reftable_iterator_seek_log(&it, u->refname);
while (ret == 0) {
struct reftable_log_record *tombstone;
@@ -1317,7 +1314,6 @@
{
struct write_copy_arg *arg = cb_data;
uint64_t deletion_ts, creation_ts;
- struct reftable_merged_table *mt = reftable_stack_merged_table(arg->stack);
struct reftable_ref_record old_ref = {0}, refs[2] = {0};
struct reftable_log_record old_log = {0}, *logs = NULL;
struct reftable_iterator it = {0};
@@ -1451,7 +1447,8 @@
* copy over all log entries from the old reflog. Last but not least,
* when renaming we also have to delete all the old reflog entries.
*/
- ret = reftable_merged_table_seek_log(mt, &it, arg->oldname);
+ reftable_stack_init_log_iterator(arg->stack, &it);
+ ret = reftable_iterator_seek_log(&it, arg->oldname);
if (ret < 0)
goto done;
@@ -1657,7 +1654,6 @@
static struct reftable_reflog_iterator *reflog_iterator_for_stack(struct reftable_ref_store *refs,
struct reftable_stack *stack)
{
- struct reftable_merged_table *merged_table;
struct reftable_reflog_iterator *iter;
int ret;
@@ -1674,9 +1670,8 @@
if (ret < 0)
goto done;
- merged_table = reftable_stack_merged_table(stack);
-
- ret = reftable_merged_table_seek_log(merged_table, &iter->iter, "");
+ reftable_stack_init_log_iterator(stack, &iter->iter);
+ ret = reftable_iterator_seek_log(&iter->iter, "");
if (ret < 0)
goto done;
@@ -1734,7 +1729,6 @@
struct reftable_ref_store *refs =
reftable_be_downcast(ref_store, REF_STORE_READ, "for_each_reflog_ent_reverse");
struct reftable_stack *stack = stack_for(refs, refname, &refname);
- struct reftable_merged_table *mt = NULL;
struct reftable_log_record log = {0};
struct reftable_iterator it = {0};
int ret;
@@ -1742,8 +1736,8 @@
if (refs->err < 0)
return refs->err;
- mt = reftable_stack_merged_table(stack);
- ret = reftable_merged_table_seek_log(mt, &it, refname);
+ reftable_stack_init_log_iterator(stack, &it);
+ ret = reftable_iterator_seek_log(&it, refname);
while (!ret) {
ret = reftable_iterator_next_log(&it, &log);
if (ret < 0)
@@ -1771,7 +1765,6 @@
struct reftable_ref_store *refs =
reftable_be_downcast(ref_store, REF_STORE_READ, "for_each_reflog_ent");
struct reftable_stack *stack = stack_for(refs, refname, &refname);
- struct reftable_merged_table *mt = NULL;
struct reftable_log_record *logs = NULL;
struct reftable_iterator it = {0};
size_t logs_alloc = 0, logs_nr = 0, i;
@@ -1780,8 +1773,8 @@
if (refs->err < 0)
return refs->err;
- mt = reftable_stack_merged_table(stack);
- ret = reftable_merged_table_seek_log(mt, &it, refname);
+ reftable_stack_init_log_iterator(stack, &it);
+ ret = reftable_iterator_seek_log(&it, refname);
while (!ret) {
struct reftable_log_record log = {0};
@@ -1818,7 +1811,6 @@
struct reftable_ref_store *refs =
reftable_be_downcast(ref_store, REF_STORE_READ, "reflog_exists");
struct reftable_stack *stack = stack_for(refs, refname, &refname);
- struct reftable_merged_table *mt = reftable_stack_merged_table(stack);
struct reftable_log_record log = {0};
struct reftable_iterator it = {0};
int ret;
@@ -1831,7 +1823,8 @@
if (ret < 0)
goto done;
- ret = reftable_merged_table_seek_log(mt, &it, refname);
+ reftable_stack_init_log_iterator(stack, &it);
+ ret = reftable_iterator_seek_log(&it, refname);
if (ret < 0)
goto done;
@@ -1929,8 +1922,6 @@
static int write_reflog_delete_table(struct reftable_writer *writer, void *cb_data)
{
struct write_reflog_delete_arg *arg = cb_data;
- struct reftable_merged_table *mt =
- reftable_stack_merged_table(arg->stack);
struct reftable_log_record log = {0}, tombstone = {0};
struct reftable_iterator it = {0};
uint64_t ts = reftable_stack_next_update_index(arg->stack);
@@ -1938,12 +1929,14 @@
reftable_writer_set_limits(writer, ts, ts);
+ reftable_stack_init_log_iterator(arg->stack, &it);
+
/*
* In order to delete a table we need to delete all reflog entries one
* by one. This is inefficient, but the reftable format does not have a
* better marker right now.
*/
- ret = reftable_merged_table_seek_log(mt, &it, arg->refname);
+ ret = reftable_iterator_seek_log(&it, arg->refname);
while (ret == 0) {
ret = reftable_iterator_next_log(&it, &log);
if (ret < 0)
@@ -2079,7 +2072,6 @@
struct reftable_ref_store *refs =
reftable_be_downcast(ref_store, REF_STORE_WRITE, "reflog_expire");
struct reftable_stack *stack = stack_for(refs, refname, &refname);
- struct reftable_merged_table *mt = reftable_stack_merged_table(stack);
struct reftable_log_record *logs = NULL;
struct reftable_log_record *rewritten = NULL;
struct reftable_ref_record ref_record = {0};
@@ -2098,7 +2090,9 @@
if (ret < 0)
goto done;
- ret = reftable_merged_table_seek_log(mt, &it, refname);
+ reftable_stack_init_log_iterator(stack, &it);
+
+ ret = reftable_iterator_seek_log(&it, refname);
if (ret < 0)
goto done;
diff --git a/reftable/block.c b/reftable/block.c
index 5942cb4..00030ee 100644
--- a/reftable/block.c
+++ b/reftable/block.c
@@ -326,9 +326,9 @@
return 0;
}
-static uint32_t block_reader_restart_offset(const struct block_reader *br, int i)
+static uint32_t block_reader_restart_offset(const struct block_reader *br, size_t idx)
{
- return get_be24(br->restart_bytes + 3 * i);
+ return get_be24(br->restart_bytes + 3 * idx);
}
void block_iter_seek_start(struct block_iter *it, const struct block_reader *br)
diff --git a/reftable/generic.c b/reftable/generic.c
index b9f1c7c..28ae261 100644
--- a/reftable/generic.c
+++ b/reftable/generic.c
@@ -12,32 +12,66 @@
#include "reftable-iterator.h"
#include "reftable-generic.h"
-int reftable_table_seek_ref(struct reftable_table *tab,
- struct reftable_iterator *it, const char *name)
+void table_init_iter(struct reftable_table *tab,
+ struct reftable_iterator *it,
+ uint8_t typ)
{
- struct reftable_record rec = { .type = BLOCK_TYPE_REF,
- .u.ref = {
- .refname = (char *)name,
- } };
- return tab->ops->seek_record(tab->table_arg, it, &rec);
+
+ tab->ops->init_iter(tab->table_arg, it, typ);
}
-int reftable_table_seek_log(struct reftable_table *tab,
- struct reftable_iterator *it, const char *name)
+void reftable_table_init_ref_iter(struct reftable_table *tab,
+ struct reftable_iterator *it)
{
- struct reftable_record rec = { .type = BLOCK_TYPE_LOG,
- .u.log = {
- .refname = (char *)name,
- .update_index = ~((uint64_t)0),
- } };
- return tab->ops->seek_record(tab->table_arg, it, &rec);
+ table_init_iter(tab, it, BLOCK_TYPE_REF);
+}
+
+void reftable_table_init_log_iter(struct reftable_table *tab,
+ struct reftable_iterator *it)
+{
+ table_init_iter(tab, it, BLOCK_TYPE_LOG);
+}
+
+int reftable_iterator_seek_ref(struct reftable_iterator *it,
+ const char *name)
+{
+ struct reftable_record want = {
+ .type = BLOCK_TYPE_REF,
+ .u.ref = {
+ .refname = (char *)name,
+ },
+ };
+ return it->ops->seek(it->iter_arg, &want);
+}
+
+int reftable_iterator_seek_log_at(struct reftable_iterator *it,
+ const char *name, uint64_t update_index)
+{
+ struct reftable_record want = {
+ .type = BLOCK_TYPE_LOG,
+ .u.log = {
+ .refname = (char *)name,
+ .update_index = update_index,
+ },
+ };
+ return it->ops->seek(it->iter_arg, &want);
+}
+
+int reftable_iterator_seek_log(struct reftable_iterator *it,
+ const char *name)
+{
+ return reftable_iterator_seek_log_at(it, name, ~((uint64_t) 0));
}
int reftable_table_read_ref(struct reftable_table *tab, const char *name,
struct reftable_ref_record *ref)
{
struct reftable_iterator it = { NULL };
- int err = reftable_table_seek_ref(tab, &it, name);
+ int err;
+
+ reftable_table_init_ref_iter(tab, &it);
+
+ err = reftable_iterator_seek_ref(&it, name);
if (err)
goto done;
@@ -62,10 +96,13 @@
struct reftable_ref_record ref = { NULL };
struct reftable_log_record log = { NULL };
uint32_t hash_id = reftable_table_hash_id(tab);
- int err = reftable_table_seek_ref(tab, &it, "");
- if (err < 0) {
+ int err;
+
+ reftable_table_init_ref_iter(tab, &it);
+
+ err = reftable_iterator_seek_ref(&it, "");
+ if (err < 0)
return err;
- }
while (1) {
err = reftable_iterator_next_ref(&it, &ref);
@@ -80,10 +117,12 @@
reftable_iterator_destroy(&it);
reftable_ref_record_release(&ref);
- err = reftable_table_seek_log(tab, &it, "");
- if (err < 0) {
+ reftable_table_init_log_iter(tab, &it);
+
+ err = reftable_iterator_seek_log(&it, "");
+ if (err < 0)
return err;
- }
+
while (1) {
err = reftable_iterator_next_log(&it, &log);
if (err > 0) {
@@ -152,11 +191,21 @@
return err;
}
+int iterator_seek(struct reftable_iterator *it, struct reftable_record *want)
+{
+ return it->ops->seek(it->iter_arg, want);
+}
+
int iterator_next(struct reftable_iterator *it, struct reftable_record *rec)
{
return it->ops->next(it->iter_arg, rec);
}
+static int empty_iterator_seek(void *arg, struct reftable_record *want)
+{
+ return 0;
+}
+
static int empty_iterator_next(void *arg, struct reftable_record *rec)
{
return 1;
@@ -167,6 +216,7 @@
}
static struct reftable_iterator_vtable empty_vtable = {
+ .seek = &empty_iterator_seek,
.next = &empty_iterator_next,
.close = &empty_iterator_close,
};
diff --git a/reftable/generic.h b/reftable/generic.h
index 98886a0..8341fa5 100644
--- a/reftable/generic.h
+++ b/reftable/generic.h
@@ -14,19 +14,24 @@
/* generic interface to reftables */
struct reftable_table_vtable {
- int (*seek_record)(void *tab, struct reftable_iterator *it,
- struct reftable_record *);
+ void (*init_iter)(void *tab, struct reftable_iterator *it, uint8_t typ);
uint32_t (*hash_id)(void *tab);
uint64_t (*min_update_index)(void *tab);
uint64_t (*max_update_index)(void *tab);
};
+void table_init_iter(struct reftable_table *tab,
+ struct reftable_iterator *it,
+ uint8_t typ);
+
struct reftable_iterator_vtable {
+ int (*seek)(void *iter_arg, struct reftable_record *want);
int (*next)(void *iter_arg, struct reftable_record *rec);
void (*close)(void *iter_arg);
};
void iterator_set_empty(struct reftable_iterator *it);
+int iterator_seek(struct reftable_iterator *it, struct reftable_record *want);
int iterator_next(struct reftable_iterator *it, struct reftable_record *rec);
#endif
diff --git a/reftable/iter.c b/reftable/iter.c
index aa9ac19..fddea31 100644
--- a/reftable/iter.c
+++ b/reftable/iter.c
@@ -23,6 +23,13 @@
reftable_iterator_destroy(&fri->it);
}
+static int filtering_ref_iterator_seek(void *iter_arg,
+ struct reftable_record *want)
+{
+ struct filtering_ref_iterator *fri = iter_arg;
+ return iterator_seek(&fri->it, want);
+}
+
static int filtering_ref_iterator_next(void *iter_arg,
struct reftable_record *rec)
{
@@ -38,11 +45,11 @@
if (fri->double_check) {
struct reftable_iterator it = { NULL };
- err = reftable_table_seek_ref(&fri->tab, &it,
- ref->refname);
- if (err == 0) {
+ reftable_table_init_ref_iter(&fri->tab, &it);
+
+ err = reftable_iterator_seek_ref(&it, ref->refname);
+ if (err == 0)
err = reftable_iterator_next_ref(&it, ref);
- }
reftable_iterator_destroy(&it);
@@ -73,6 +80,7 @@
}
static struct reftable_iterator_vtable filtering_ref_iterator_vtable = {
+ .seek = &filtering_ref_iterator_seek,
.next = &filtering_ref_iterator_next,
.close = &filtering_ref_iterator_close,
};
@@ -119,6 +127,12 @@
return 0;
}
+static int indexed_table_ref_iter_seek(void *p, struct reftable_record *want)
+{
+ BUG("seeking indexed table is not supported");
+ return -1;
+}
+
static int indexed_table_ref_iter_next(void *p, struct reftable_record *rec)
{
struct indexed_table_ref_iter *it = p;
@@ -175,6 +189,7 @@
}
static struct reftable_iterator_vtable indexed_table_ref_iter_vtable = {
+ .seek = &indexed_table_ref_iter_seek,
.next = &indexed_table_ref_iter_next,
.close = &indexed_table_ref_iter_close,
};
diff --git a/reftable/merged.c b/reftable/merged.c
index f85a24c..0da9dba 100644
--- a/reftable/merged.c
+++ b/reftable/merged.c
@@ -25,34 +25,25 @@
struct merged_iter {
struct merged_subiter *subiters;
struct merged_iter_pqueue pq;
- uint32_t hash_id;
size_t stack_len;
- uint8_t typ;
int suppress_deletions;
ssize_t advance_index;
};
-static int merged_iter_init(struct merged_iter *mi)
+static void merged_iter_init(struct merged_iter *mi,
+ struct reftable_merged_table *mt,
+ uint8_t typ)
{
- for (size_t i = 0; i < mi->stack_len; i++) {
- struct pq_entry e = {
- .index = i,
- .rec = &mi->subiters[i].rec,
- };
- int err;
+ memset(mi, 0, sizeof(*mi));
+ mi->advance_index = -1;
+ mi->suppress_deletions = mt->suppress_deletions;
- reftable_record_init(&mi->subiters[i].rec, mi->typ);
- err = iterator_next(&mi->subiters[i].iter,
- &mi->subiters[i].rec);
- if (err < 0)
- return err;
- if (err > 0)
- continue;
-
- merged_iter_pqueue_add(&mi->pq, &e);
+ REFTABLE_CALLOC_ARRAY(mi->subiters, mt->stack_len);
+ for (size_t i = 0; i < mt->stack_len; i++) {
+ reftable_record_init(&mi->subiters[i].rec, typ);
+ table_init_iter(&mt->stack[i], &mi->subiters[i].iter, typ);
}
-
- return 0;
+ mi->stack_len = mt->stack_len;
}
static void merged_iter_close(void *p)
@@ -83,6 +74,27 @@
return 0;
}
+static int merged_iter_seek(struct merged_iter *mi, struct reftable_record *want)
+{
+ int err;
+
+ mi->advance_index = -1;
+
+ for (size_t i = 0; i < mi->stack_len; i++) {
+ err = iterator_seek(&mi->subiters[i].iter, want);
+ if (err < 0)
+ return err;
+ if (err > 0)
+ continue;
+
+ err = merged_iter_advance_subiter(mi, i);
+ if (err < 0)
+ return err;
+ }
+
+ return 0;
+}
+
static int merged_iter_next_entry(struct merged_iter *mi,
struct reftable_record *rec)
{
@@ -148,6 +160,11 @@
return 0;
}
+static int merged_iter_seek_void(void *it, struct reftable_record *want)
+{
+ return merged_iter_seek(it, want);
+}
+
static int merged_iter_next_void(void *p, struct reftable_record *rec)
{
struct merged_iter *mi = p;
@@ -162,6 +179,7 @@
}
static struct reftable_iterator_vtable merged_iter_vtable = {
+ .seek = merged_iter_seek_void,
.next = &merged_iter_next_void,
.close = &merged_iter_close,
};
@@ -235,81 +253,13 @@
return mt->min;
}
-static int reftable_table_seek_record(struct reftable_table *tab,
- struct reftable_iterator *it,
- struct reftable_record *rec)
+void merged_table_init_iter(struct reftable_merged_table *mt,
+ struct reftable_iterator *it,
+ uint8_t typ)
{
- return tab->ops->seek_record(tab->table_arg, it, rec);
-}
-
-static int merged_table_seek_record(struct reftable_merged_table *mt,
- struct reftable_iterator *it,
- struct reftable_record *rec)
-{
- struct merged_iter merged = {
- .typ = reftable_record_type(rec),
- .hash_id = mt->hash_id,
- .suppress_deletions = mt->suppress_deletions,
- .advance_index = -1,
- };
- struct merged_iter *p;
- int err;
-
- REFTABLE_CALLOC_ARRAY(merged.subiters, mt->stack_len);
- for (size_t i = 0; i < mt->stack_len; i++) {
- err = reftable_table_seek_record(&mt->stack[i],
- &merged.subiters[merged.stack_len].iter, rec);
- if (err < 0)
- goto out;
- if (!err)
- merged.stack_len++;
- }
-
- err = merged_iter_init(&merged);
- if (err < 0)
- goto out;
-
- p = reftable_malloc(sizeof(struct merged_iter));
- *p = merged;
- iterator_from_merged_iter(it, p);
-
-out:
- if (err < 0)
- merged_iter_close(&merged);
- return err;
-}
-
-int reftable_merged_table_seek_ref(struct reftable_merged_table *mt,
- struct reftable_iterator *it,
- const char *name)
-{
- struct reftable_record rec = {
- .type = BLOCK_TYPE_REF,
- .u.ref = {
- .refname = (char *)name,
- },
- };
- return merged_table_seek_record(mt, it, &rec);
-}
-
-int reftable_merged_table_seek_log_at(struct reftable_merged_table *mt,
- struct reftable_iterator *it,
- const char *name, uint64_t update_index)
-{
- struct reftable_record rec = { .type = BLOCK_TYPE_LOG,
- .u.log = {
- .refname = (char *)name,
- .update_index = update_index,
- } };
- return merged_table_seek_record(mt, it, &rec);
-}
-
-int reftable_merged_table_seek_log(struct reftable_merged_table *mt,
- struct reftable_iterator *it,
- const char *name)
-{
- uint64_t max = ~((uint64_t)0);
- return reftable_merged_table_seek_log_at(mt, it, name, max);
+ struct merged_iter *mi = reftable_malloc(sizeof(*mi));
+ merged_iter_init(mi, mt, typ);
+ iterator_from_merged_iter(it, mi);
}
uint32_t reftable_merged_table_hash_id(struct reftable_merged_table *mt)
@@ -317,11 +267,11 @@
return mt->hash_id;
}
-static int reftable_merged_table_seek_void(void *tab,
- struct reftable_iterator *it,
- struct reftable_record *rec)
+static void reftable_merged_table_init_iter_void(void *tab,
+ struct reftable_iterator *it,
+ uint8_t typ)
{
- return merged_table_seek_record(tab, it, rec);
+ merged_table_init_iter(tab, it, typ);
}
static uint32_t reftable_merged_table_hash_id_void(void *tab)
@@ -340,7 +290,7 @@
}
static struct reftable_table_vtable merged_table_vtable = {
- .seek_record = reftable_merged_table_seek_void,
+ .init_iter = reftable_merged_table_init_iter_void,
.hash_id = reftable_merged_table_hash_id_void,
.min_update_index = reftable_merged_table_min_update_index_void,
.max_update_index = reftable_merged_table_max_update_index_void,
diff --git a/reftable/merged.h b/reftable/merged.h
index a2571db..a10469f 100644
--- a/reftable/merged.h
+++ b/reftable/merged.h
@@ -26,4 +26,10 @@
void merged_table_release(struct reftable_merged_table *mt);
+struct reftable_iterator;
+
+void merged_table_init_iter(struct reftable_merged_table *mt,
+ struct reftable_iterator *it,
+ uint8_t typ);
+
#endif
diff --git a/reftable/merged_test.c b/reftable/merged_test.c
index 4ac81de..02a8056 100644
--- a/reftable/merged_test.c
+++ b/reftable/merged_test.c
@@ -12,6 +12,7 @@
#include "basics.h"
#include "blocksource.h"
+#include "constants.h"
#include "reader.h"
#include "record.h"
#include "test_framework.h"
@@ -145,7 +146,10 @@
int i;
struct reftable_ref_record ref = { NULL };
struct reftable_iterator it = { NULL };
- int err = reftable_merged_table_seek_ref(mt, &it, "a");
+ int err;
+
+ merged_table_init_iter(mt, &it, BLOCK_TYPE_REF);
+ err = reftable_iterator_seek_ref(&it, "a");
EXPECT_ERR(err);
err = reftable_iterator_next_ref(&it, &ref);
@@ -217,14 +221,15 @@
struct reftable_reader **readers = NULL;
struct reftable_merged_table *mt =
merged_table_from_records(refs, &bs, &readers, sizes, bufs, 3);
-
struct reftable_iterator it = { NULL };
- int err = reftable_merged_table_seek_ref(mt, &it, "a");
+ int err;
struct reftable_ref_record *out = NULL;
size_t len = 0;
size_t cap = 0;
int i = 0;
+ merged_table_init_iter(mt, &it, BLOCK_TYPE_REF);
+ err = reftable_iterator_seek_ref(&it, "a");
EXPECT_ERR(err);
EXPECT(reftable_merged_table_hash_id(mt) == GIT_SHA1_FORMAT_ID);
EXPECT(reftable_merged_table_min_update_index(mt) == 1);
@@ -348,14 +353,15 @@
struct reftable_reader **readers = NULL;
struct reftable_merged_table *mt = merged_table_from_log_records(
logs, &bs, &readers, sizes, bufs, 3);
-
struct reftable_iterator it = { NULL };
- int err = reftable_merged_table_seek_log(mt, &it, "a");
+ int err;
struct reftable_log_record *out = NULL;
size_t len = 0;
size_t cap = 0;
int i = 0;
+ merged_table_init_iter(mt, &it, BLOCK_TYPE_LOG);
+ err = reftable_iterator_seek_log(&it, "a");
EXPECT_ERR(err);
EXPECT(reftable_merged_table_hash_id(mt) == GIT_SHA1_FORMAT_ID);
EXPECT(reftable_merged_table_min_update_index(mt) == 1);
@@ -377,7 +383,8 @@
GIT_SHA1_RAWSZ));
}
- err = reftable_merged_table_seek_log_at(mt, &it, "a", 2);
+ merged_table_init_iter(mt, &it, BLOCK_TYPE_LOG);
+ err = reftable_iterator_seek_log_at(&it, "a", 2);
EXPECT_ERR(err);
reftable_log_record_release(&out[0]);
err = reftable_iterator_next_log(&it, &out[0]);
diff --git a/reftable/reader.c b/reftable/reader.c
index f23c852..29c99e2 100644
--- a/reftable/reader.c
+++ b/reftable/reader.c
@@ -224,8 +224,14 @@
struct block_iter bi;
int is_finished;
};
-#define TABLE_ITER_INIT { \
- .bi = BLOCK_ITER_INIT \
+
+static int table_iter_init(struct table_iter *ti, struct reftable_reader *r)
+{
+ struct block_iter bi = BLOCK_ITER_INIT;
+ memset(ti, 0, sizeof(*ti));
+ ti->r = r;
+ ti->bi = bi;
+ return 0;
}
static int table_iter_next_in_block(struct table_iter *ti,
@@ -363,50 +369,23 @@
}
}
-static int table_iter_next_void(void *ti, struct reftable_record *rec)
-{
- return table_iter_next(ti, rec);
-}
-
-static void table_iter_close_void(void *ti)
-{
- table_iter_close(ti);
-}
-
-static struct reftable_iterator_vtable table_iter_vtable = {
- .next = &table_iter_next_void,
- .close = &table_iter_close_void,
-};
-
-static void iterator_from_table_iter(struct reftable_iterator *it,
- struct table_iter *ti)
-{
- assert(!it->ops);
- it->iter_arg = ti;
- it->ops = &table_iter_vtable;
-}
-
-static int reader_table_iter_at(struct reftable_reader *r,
- struct table_iter *ti, uint64_t off,
- uint8_t typ)
+static int table_iter_seek_to(struct table_iter *ti, uint64_t off, uint8_t typ)
{
int err;
- err = reader_init_block_reader(r, &ti->br, off, typ);
+ err = reader_init_block_reader(ti->r, &ti->br, off, typ);
if (err != 0)
return err;
- ti->r = r;
ti->typ = block_reader_type(&ti->br);
ti->block_off = off;
block_iter_seek_start(&ti->bi, &ti->br);
return 0;
}
-static int reader_start(struct reftable_reader *r, struct table_iter *ti,
- uint8_t typ, int index)
+static int table_iter_seek_start(struct table_iter *ti, uint8_t typ, int index)
{
- struct reftable_reader_offsets *offs = reader_offsets_for(r, typ);
+ struct reftable_reader_offsets *offs = reader_offsets_for(ti->r, typ);
uint64_t off = offs->offset;
if (index) {
off = offs->index_offset;
@@ -416,16 +395,16 @@
typ = BLOCK_TYPE_INDEX;
}
- return reader_table_iter_at(r, ti, off, typ);
+ return table_iter_seek_to(ti, off, typ);
}
-static int reader_seek_linear(struct table_iter *ti,
- struct reftable_record *want)
+static int table_iter_seek_linear(struct table_iter *ti,
+ struct reftable_record *want)
{
struct strbuf want_key = STRBUF_INIT;
struct strbuf got_key = STRBUF_INIT;
struct reftable_record rec;
- int err = -1;
+ int err;
reftable_record_init(&rec, reftable_record_type(want));
reftable_record_key(want, &want_key);
@@ -499,9 +478,8 @@
return err;
}
-static int reader_seek_indexed(struct reftable_reader *r,
- struct reftable_iterator *it,
- struct reftable_record *rec)
+static int table_iter_seek_indexed(struct table_iter *ti,
+ struct reftable_record *rec)
{
struct reftable_record want_index = {
.type = BLOCK_TYPE_INDEX, .u.idx = { .last_key = STRBUF_INIT }
@@ -510,15 +488,9 @@
.type = BLOCK_TYPE_INDEX,
.u.idx = { .last_key = STRBUF_INIT },
};
- struct table_iter index_iter = TABLE_ITER_INIT;
- struct table_iter empty = TABLE_ITER_INIT;
- struct table_iter next = TABLE_ITER_INIT;
- int err = 0;
+ int err;
reftable_record_key(rec, &want_index.u.idx.last_key);
- err = reader_start(r, &index_iter, reftable_record_type(rec), 1);
- if (err < 0)
- goto done;
/*
* The index may consist of multiple levels, where each level may have
@@ -526,7 +498,7 @@
* highest layer that identifies the relevant index block as well as
* the record inside that block that corresponds to our wanted key.
*/
- err = reader_seek_linear(&index_iter, &want_index);
+ err = table_iter_seek_linear(ti, &want_index);
if (err < 0)
goto done;
@@ -552,123 +524,113 @@
* all levels of the index only to find out that the key does
* not exist.
*/
- err = table_iter_next(&index_iter, &index_result);
+ err = table_iter_next(ti, &index_result);
if (err != 0)
goto done;
- err = reader_table_iter_at(r, &next, index_result.u.idx.offset,
- 0);
+ err = table_iter_seek_to(ti, index_result.u.idx.offset, 0);
if (err != 0)
goto done;
- err = block_iter_seek_key(&next.bi, &next.br, &want_index.u.idx.last_key);
+ err = block_iter_seek_key(&ti->bi, &ti->br, &want_index.u.idx.last_key);
if (err < 0)
goto done;
- if (next.typ == reftable_record_type(rec)) {
+ if (ti->typ == reftable_record_type(rec)) {
err = 0;
break;
}
- if (next.typ != BLOCK_TYPE_INDEX) {
+ if (ti->typ != BLOCK_TYPE_INDEX) {
err = REFTABLE_FORMAT_ERROR;
- break;
+ goto done;
}
-
- table_iter_close(&index_iter);
- index_iter = next;
- next = empty;
- }
-
- if (err == 0) {
- struct table_iter *malloced = reftable_calloc(1, sizeof(*malloced));
- *malloced = next;
- next = empty;
- iterator_from_table_iter(it, malloced);
}
done:
- table_iter_close(&next);
- table_iter_close(&index_iter);
reftable_record_release(&want_index);
reftable_record_release(&index_result);
return err;
}
-static int reader_seek_internal(struct reftable_reader *r,
- struct reftable_iterator *it,
- struct reftable_record *rec)
+static int table_iter_seek(struct table_iter *ti,
+ struct reftable_record *want)
{
- struct reftable_reader_offsets *offs =
- reader_offsets_for(r, reftable_record_type(rec));
- uint64_t idx = offs->index_offset;
- struct table_iter ti = TABLE_ITER_INIT, *p;
+ uint8_t typ = reftable_record_type(want);
+ struct reftable_reader_offsets *offs = reader_offsets_for(ti->r, typ);
int err;
- if (idx > 0)
- return reader_seek_indexed(r, it, rec);
-
- err = reader_start(r, &ti, reftable_record_type(rec), 0);
+ err = table_iter_seek_start(ti, reftable_record_type(want),
+ !!offs->index_offset);
if (err < 0)
goto out;
- err = reader_seek_linear(&ti, rec);
- if (err < 0)
+ if (offs->index_offset)
+ err = table_iter_seek_indexed(ti, want);
+ else
+ err = table_iter_seek_linear(ti, want);
+ if (err)
goto out;
- REFTABLE_ALLOC_ARRAY(p, 1);
- *p = ti;
- iterator_from_table_iter(it, p);
-
out:
- if (err)
- table_iter_close(&ti);
return err;
}
-static int reader_seek(struct reftable_reader *r, struct reftable_iterator *it,
- struct reftable_record *rec)
+static int table_iter_seek_void(void *ti, struct reftable_record *want)
{
- uint8_t typ = reftable_record_type(rec);
+ return table_iter_seek(ti, want);
+}
+static int table_iter_next_void(void *ti, struct reftable_record *rec)
+{
+ return table_iter_next(ti, rec);
+}
+
+static void table_iter_close_void(void *ti)
+{
+ table_iter_close(ti);
+}
+
+static struct reftable_iterator_vtable table_iter_vtable = {
+ .seek = &table_iter_seek_void,
+ .next = &table_iter_next_void,
+ .close = &table_iter_close_void,
+};
+
+static void iterator_from_table_iter(struct reftable_iterator *it,
+ struct table_iter *ti)
+{
+ assert(!it->ops);
+ it->iter_arg = ti;
+ it->ops = &table_iter_vtable;
+}
+
+static void reader_init_iter(struct reftable_reader *r,
+ struct reftable_iterator *it,
+ uint8_t typ)
+{
struct reftable_reader_offsets *offs = reader_offsets_for(r, typ);
- if (!offs->is_present) {
+
+ if (offs->is_present) {
+ struct table_iter *ti;
+ REFTABLE_ALLOC_ARRAY(ti, 1);
+ table_iter_init(ti, r);
+ iterator_from_table_iter(it, ti);
+ } else {
iterator_set_empty(it);
- return 0;
}
-
- return reader_seek_internal(r, it, rec);
}
-int reftable_reader_seek_ref(struct reftable_reader *r,
- struct reftable_iterator *it, const char *name)
+void reftable_reader_init_ref_iterator(struct reftable_reader *r,
+ struct reftable_iterator *it)
{
- struct reftable_record rec = {
- .type = BLOCK_TYPE_REF,
- .u.ref = {
- .refname = (char *)name,
- },
- };
- return reader_seek(r, it, &rec);
+ reader_init_iter(r, it, BLOCK_TYPE_REF);
}
-int reftable_reader_seek_log_at(struct reftable_reader *r,
- struct reftable_iterator *it, const char *name,
- uint64_t update_index)
+void reftable_reader_init_log_iterator(struct reftable_reader *r,
+ struct reftable_iterator *it)
{
- struct reftable_record rec = { .type = BLOCK_TYPE_LOG,
- .u.log = {
- .refname = (char *)name,
- .update_index = update_index,
- } };
- return reader_seek(r, it, &rec);
-}
-
-int reftable_reader_seek_log(struct reftable_reader *r,
- struct reftable_iterator *it, const char *name)
-{
- uint64_t max = ~((uint64_t)0);
- return reftable_reader_seek_log_at(r, it, name, max);
+ reader_init_iter(r, it, BLOCK_TYPE_LOG);
}
void reader_close(struct reftable_reader *r)
@@ -719,7 +681,8 @@
struct indexed_table_ref_iter *itr = NULL;
/* Look through the reverse index. */
- err = reader_seek(r, &oit, &want);
+ reader_init_iter(r, &oit, BLOCK_TYPE_OBJ);
+ err = iterator_seek(&oit, &want);
if (err != 0)
goto done;
@@ -754,15 +717,15 @@
struct reftable_iterator *it,
uint8_t *oid)
{
- struct table_iter ti_empty = TABLE_ITER_INIT;
- struct table_iter *ti = reftable_calloc(1, sizeof(*ti));
+ struct table_iter *ti;
struct filtering_ref_iterator *filter = NULL;
struct filtering_ref_iterator empty = FILTERING_REF_ITERATOR_INIT;
int oid_len = hash_size(r->hash_id);
int err;
- *ti = ti_empty;
- err = reader_start(r, ti, BLOCK_TYPE_REF, 0);
+ REFTABLE_ALLOC_ARRAY(ti, 1);
+ table_iter_init(ti, r);
+ err = table_iter_seek_start(ti, BLOCK_TYPE_REF, 0);
if (err < 0) {
reftable_free(ti);
return err;
@@ -800,10 +763,11 @@
/* generic table interface. */
-static int reftable_reader_seek_void(void *tab, struct reftable_iterator *it,
- struct reftable_record *rec)
+static void reftable_reader_init_iter_void(void *tab,
+ struct reftable_iterator *it,
+ uint8_t typ)
{
- return reader_seek(tab, it, rec);
+ reader_init_iter(tab, it, typ);
}
static uint32_t reftable_reader_hash_id_void(void *tab)
@@ -822,7 +786,7 @@
}
static struct reftable_table_vtable reader_vtable = {
- .seek_record = reftable_reader_seek_void,
+ .init_iter = reftable_reader_init_iter_void,
.hash_id = reftable_reader_hash_id_void,
.min_update_index = reftable_reader_min_update_index_void,
.max_update_index = reftable_reader_max_update_index_void,
@@ -877,8 +841,8 @@
},
};
struct reftable_block_source src = { 0 };
- struct table_iter ti = TABLE_ITER_INIT;
struct reftable_reader *r = NULL;
+ struct table_iter ti = { 0 };
size_t i;
int err;
@@ -890,11 +854,13 @@
if (err < 0)
goto done;
+ table_iter_init(&ti, r);
+
printf("header:\n");
printf(" block_size: %d\n", r->block_size);
for (i = 0; i < ARRAY_SIZE(sections); i++) {
- err = reader_start(r, &ti, sections[i].type, 0);
+ err = table_iter_seek_start(&ti, sections[i].type, 0);
if (err < 0)
goto done;
if (err > 0)
diff --git a/reftable/readwrite_test.c b/reftable/readwrite_test.c
index 27631a0..bcebd87 100644
--- a/reftable/readwrite_test.c
+++ b/reftable/readwrite_test.c
@@ -239,7 +239,9 @@
err = init_reader(&rd, &source, "file.log");
EXPECT_ERR(err);
- err = reftable_reader_seek_ref(&rd, &it, names[N - 1]);
+ reftable_reader_init_ref_iterator(&rd, &it);
+
+ err = reftable_iterator_seek_ref(&it, names[N - 1]);
EXPECT_ERR(err);
err = reftable_iterator_next_ref(&it, &ref);
@@ -252,7 +254,9 @@
reftable_iterator_destroy(&it);
reftable_ref_record_release(&ref);
- err = reftable_reader_seek_log(&rd, &it, "");
+ reftable_reader_init_log_iterator(&rd, &it);
+
+ err = reftable_iterator_seek_log(&it, "");
EXPECT_ERR(err);
i = 0;
@@ -330,7 +334,8 @@
err = init_reader(&rd, &source, "file.log");
EXPECT_ERR(err);
- err = reftable_reader_seek_log(&rd, &it, "refname");
+ reftable_reader_init_log_iterator(&rd, &it);
+ err = reftable_iterator_seek_log(&it, "refname");
EXPECT(err == REFTABLE_ZLIB_ERROR);
reftable_iterator_destroy(&it);
@@ -358,7 +363,8 @@
err = init_reader(&rd, &source, "file.ref");
EXPECT_ERR(err);
- err = reftable_reader_seek_ref(&rd, &it, "");
+ reftable_reader_init_ref_iterator(&rd, &it);
+ err = reftable_iterator_seek_ref(&it, "");
EXPECT_ERR(err);
while (1) {
@@ -412,7 +418,8 @@
err = init_reader(&rd, &source, "file.ref");
EXPECT_ERR(err);
- err = reftable_reader_seek_ref(&rd, &it, names[0]);
+ reftable_reader_init_ref_iterator(&rd, &it);
+ err = reftable_iterator_seek_ref(&it, names[0]);
EXPECT_ERR(err);
err = reftable_iterator_next_log(&it, &log);
@@ -457,7 +464,8 @@
}
for (i = 1; i < N; i++) {
- int err = reftable_reader_seek_ref(&rd, &it, names[i]);
+ reftable_reader_init_ref_iterator(&rd, &it);
+ err = reftable_iterator_seek_ref(&it, names[i]);
EXPECT_ERR(err);
err = reftable_iterator_next_ref(&it, &ref);
EXPECT_ERR(err);
@@ -472,7 +480,8 @@
strbuf_addstr(&pastLast, names[N - 1]);
strbuf_addstr(&pastLast, "/");
- err = reftable_reader_seek_ref(&rd, &it, pastLast.buf);
+ reftable_reader_init_ref_iterator(&rd, &it);
+ err = reftable_iterator_seek_ref(&it, pastLast.buf);
if (err == 0) {
struct reftable_ref_record ref = { NULL };
int err = reftable_iterator_next_ref(&it, &ref);
@@ -576,7 +585,8 @@
rd.obj_offsets.is_present = 0;
}
- err = reftable_reader_seek_ref(&rd, &it, "");
+ reftable_reader_init_ref_iterator(&rd, &it);
+ err = reftable_iterator_seek_ref(&it, "");
EXPECT_ERR(err);
reftable_iterator_destroy(&it);
@@ -639,7 +649,8 @@
err = reftable_new_reader(&rd, &source, "filename");
EXPECT_ERR(err);
- err = reftable_reader_seek_ref(rd, &it, "");
+ reftable_reader_init_ref_iterator(rd, &it);
+ err = reftable_iterator_seek_ref(&it, "");
EXPECT_ERR(err);
err = reftable_iterator_next_ref(&it, &rec);
@@ -846,7 +857,8 @@
* Seeking the log uses the log index now. In case there is any
* confusion regarding indices we would notice here.
*/
- err = reftable_reader_seek_log(reader, &it, "");
+ reftable_reader_init_log_iterator(reader, &it);
+ err = reftable_iterator_seek_log(&it, "");
EXPECT_ERR(err);
reftable_iterator_destroy(&it);
@@ -901,7 +913,8 @@
/*
* Seeking the last ref should work as expected.
*/
- err = reftable_reader_seek_ref(reader, &it, "refs/heads/199");
+ reftable_reader_init_ref_iterator(reader, &it);
+ err = reftable_iterator_seek_ref(&it, "refs/heads/199");
EXPECT_ERR(err);
reftable_iterator_destroy(&it);
diff --git a/reftable/reftable-generic.h b/reftable/reftable-generic.h
index d239751..65670ea 100644
--- a/reftable/reftable-generic.h
+++ b/reftable/reftable-generic.h
@@ -21,11 +21,11 @@
void *table_arg;
};
-int reftable_table_seek_log(struct reftable_table *tab,
- struct reftable_iterator *it, const char *name);
+void reftable_table_init_ref_iter(struct reftable_table *tab,
+ struct reftable_iterator *it);
-int reftable_table_seek_ref(struct reftable_table *tab,
- struct reftable_iterator *it, const char *name);
+void reftable_table_init_log_iter(struct reftable_table *tab,
+ struct reftable_iterator *it);
/* returns the hash ID from a generic reftable_table */
uint32_t reftable_table_hash_id(struct reftable_table *tab);
diff --git a/reftable/reftable-iterator.h b/reftable/reftable-iterator.h
index d3eee7a..e3bf688 100644
--- a/reftable/reftable-iterator.h
+++ b/reftable/reftable-iterator.h
@@ -21,12 +21,33 @@
void *iter_arg;
};
+/*
+ * Position the iterator at the ref record with given name such that the next
+ * call to `next_ref()` would yield the record.
+ */
+int reftable_iterator_seek_ref(struct reftable_iterator *it,
+ const char *name);
+
/* reads the next reftable_ref_record. Returns < 0 for error, 0 for OK and > 0:
* end of iteration.
*/
int reftable_iterator_next_ref(struct reftable_iterator *it,
struct reftable_ref_record *ref);
+/*
+ * Position the iterator at the log record with given name and update index
+ * such that the next call to `next_log()` would yield the record.
+ */
+int reftable_iterator_seek_log_at(struct reftable_iterator *it,
+ const char *name, uint64_t update_index);
+
+/*
+ * Position the iterator at the newest log record with given name such that the
+ * next call to `next_log()` would yield the record.
+ */
+int reftable_iterator_seek_log(struct reftable_iterator *it,
+ const char *name);
+
/* reads the next reftable_log_record. Returns < 0 for error, 0 for OK and > 0:
* end of iteration.
*/
diff --git a/reftable/reftable-merged.h b/reftable/reftable-merged.h
index c91a2d8..14d5fc9 100644
--- a/reftable/reftable-merged.h
+++ b/reftable/reftable-merged.h
@@ -36,21 +36,6 @@
struct reftable_table *stack, size_t n,
uint32_t hash_id);
-/* returns an iterator positioned just before 'name' */
-int reftable_merged_table_seek_ref(struct reftable_merged_table *mt,
- struct reftable_iterator *it,
- const char *name);
-
-/* returns an iterator for log entry, at given update_index */
-int reftable_merged_table_seek_log_at(struct reftable_merged_table *mt,
- struct reftable_iterator *it,
- const char *name, uint64_t update_index);
-
-/* like reftable_merged_table_seek_log_at but look for the newest entry. */
-int reftable_merged_table_seek_log(struct reftable_merged_table *mt,
- struct reftable_iterator *it,
- const char *name);
-
/* returns the max update_index covered by this merged table. */
uint64_t
reftable_merged_table_max_update_index(struct reftable_merged_table *mt);
diff --git a/reftable/reftable-reader.h b/reftable/reftable-reader.h
index 4a04857..7e1c632 100644
--- a/reftable/reftable-reader.h
+++ b/reftable/reftable-reader.h
@@ -36,48 +36,17 @@
int reftable_new_reader(struct reftable_reader **pp,
struct reftable_block_source *src, const char *name);
-/* reftable_reader_seek_ref returns an iterator where 'name' would be inserted
- in the table. To seek to the start of the table, use name = "".
+/* Initialize a reftable iterator for reading refs. */
+void reftable_reader_init_ref_iterator(struct reftable_reader *r,
+ struct reftable_iterator *it);
- example:
-
- struct reftable_reader *r = NULL;
- int err = reftable_new_reader(&r, &src, "filename");
- if (err < 0) { ... }
- struct reftable_iterator it = {0};
- err = reftable_reader_seek_ref(r, &it, "refs/heads/master");
- if (err < 0) { ... }
- struct reftable_ref_record ref = {0};
- while (1) {
- err = reftable_iterator_next_ref(&it, &ref);
- if (err > 0) {
- break;
- }
- if (err < 0) {
- ..error handling..
- }
- ..found..
- }
- reftable_iterator_destroy(&it);
- reftable_ref_record_release(&ref);
-*/
-int reftable_reader_seek_ref(struct reftable_reader *r,
- struct reftable_iterator *it, const char *name);
+/* Initialize a reftable iterator for reading refs. */
+void reftable_reader_init_log_iterator(struct reftable_reader *r,
+ struct reftable_iterator *it);
/* returns the hash ID used in this table. */
uint32_t reftable_reader_hash_id(struct reftable_reader *r);
-/* seek to logs for the given name, older than update_index. To seek to the
- start of the table, use name = "".
-*/
-int reftable_reader_seek_log_at(struct reftable_reader *r,
- struct reftable_iterator *it, const char *name,
- uint64_t update_index);
-
-/* seek to newest log entry for given name. */
-int reftable_reader_seek_log(struct reftable_reader *r,
- struct reftable_iterator *it, const char *name);
-
/* closes and deallocates a reader. */
void reftable_reader_free(struct reftable_reader *);
diff --git a/reftable/reftable-stack.h b/reftable/reftable-stack.h
index 9c8e4ee..1e7c90b 100644
--- a/reftable/reftable-stack.h
+++ b/reftable/reftable-stack.h
@@ -66,6 +66,24 @@
void *write_arg),
void *write_arg);
+struct reftable_iterator;
+
+/*
+ * Initialize an iterator for the merged tables contained in the stack that can
+ * be used to iterate through refs. The iterator is valid until the next reload
+ * or write.
+ */
+void reftable_stack_init_ref_iterator(struct reftable_stack *st,
+ struct reftable_iterator *it);
+
+/*
+ * Initialize an iterator for the merged tables contained in the stack that can
+ * be used to iterate through logs. The iterator is valid until the next reload
+ * or write.
+ */
+void reftable_stack_init_log_iterator(struct reftable_stack *st,
+ struct reftable_iterator *it);
+
/* returns the merged_table for seeking. This table is valid until the
* next write or reload, and should not be closed or deleted.
*/
diff --git a/reftable/stack.c b/reftable/stack.c
index ed28a50..44b3a76 100644
--- a/reftable/stack.c
+++ b/reftable/stack.c
@@ -130,6 +130,20 @@
return err;
}
+void reftable_stack_init_ref_iterator(struct reftable_stack *st,
+ struct reftable_iterator *it)
+{
+ merged_table_init_iter(reftable_stack_merged_table(st),
+ it, BLOCK_TYPE_REF);
+}
+
+void reftable_stack_init_log_iterator(struct reftable_stack *st,
+ struct reftable_iterator *it)
+{
+ merged_table_init_iter(reftable_stack_merged_table(st),
+ it, BLOCK_TYPE_LOG);
+}
+
struct reftable_merged_table *
reftable_stack_merged_table(struct reftable_stack *st)
{
@@ -910,7 +924,8 @@
goto done;
}
- err = reftable_merged_table_seek_ref(mt, &it, "");
+ merged_table_init_iter(mt, &it, BLOCK_TYPE_REF);
+ err = reftable_iterator_seek_ref(&it, "");
if (err < 0)
goto done;
@@ -934,7 +949,8 @@
}
reftable_iterator_destroy(&it);
- err = reftable_merged_table_seek_log(mt, &it, "");
+ merged_table_init_iter(mt, &it, BLOCK_TYPE_LOG);
+ err = reftable_iterator_seek_log(&it, "");
if (err < 0)
goto done;
@@ -1330,9 +1346,11 @@
int reftable_stack_read_log(struct reftable_stack *st, const char *refname,
struct reftable_log_record *log)
{
- struct reftable_iterator it = { NULL };
- struct reftable_merged_table *mt = reftable_stack_merged_table(st);
- int err = reftable_merged_table_seek_log(mt, &it, refname);
+ struct reftable_iterator it = {0};
+ int err;
+
+ reftable_stack_init_log_iterator(st, &it);
+ err = reftable_iterator_seek_log(&it, refname);
if (err)
goto done;
