reftable/reader: adapt interface to allow reuse of iterators

Refactor the interfaces exposed by `struct reftable_reader` and `struct
table_iterator` such that they support iterator reuse. This is done by
separating initialization of the iterator and seeking on it.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/reftable/reader.c b/reftable/reader.c
index a5a13cb0b919ec1d61e75ba7ac65590db761da4f..bbdb4bdafa1f4283cbd271117522d64da8e0efb7 100644 (file)
--- a/reftable/reader.c
+++ b/reftable/reader.c
@@ -621,39 +621,16 @@ static void reader_init_iter(struct reftable_reader *r,
        }
 }
 
-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,
-               },
-       };
        reader_init_iter(r, it, BLOCK_TYPE_REF);
-       return iterator_seek(it, &rec);
 }
 
-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,
-               },
-       };
        reader_init_iter(r, it, BLOCK_TYPE_LOG);
-       return iterator_seek(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);
 }
 
 void reader_close(struct reftable_reader *r)

diff --git a/reftable/readwrite_test.c b/reftable/readwrite_test.c
index a6dbd214c5d2f8c9a82632776691fe1c292533bd..d99543bbd67b86c3606f9a1ef1fd05b99587c1d7 100644 (file)
--- a/reftable/readwrite_test.c
+++ b/reftable/readwrite_test.c
@@ -239,7 +239,9 @@ static void test_log_write_read(void)
        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 @@ static void test_log_write_read(void)
        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 @@ static void test_log_zlib_corruption(void)
        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 @@ static void test_table_read_write_sequential(void)
        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 @@ static void test_table_read_api(void)
        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 @@ static void test_table_read_write_seek(int index, int hash_id)
        }
 
        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 @@ static void test_table_read_write_seek(int index, int hash_id)
        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 @@ static void test_table_refs_for(int indexed)
                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 @@ static void test_write_empty_table(void)
        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 @@ static void test_write_multiple_indices(void)
         * 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 @@ static void test_write_multi_level_index(void)
        /*
         * 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-reader.h b/reftable/reftable-reader.h
index 4a4bc2fdf85a542d68614cdfc500af108d4ad17c..52e4942b7ba1687d940bf88bca104319d4021aa1 100644 (file)
--- a/reftable/reftable-reader.h
+++ b/reftable/reftable-reader.h
@@ -36,48 +36,17 @@ struct reftable_table;
 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 = "".
-
-   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_ref_iterator(struct reftable_reader *r,
+                                      struct reftable_iterator *it);
+
+/* Initialize a reftable iterator for reading logs. */
+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 *);