@matheusbsbs / matheus-bagliano / commits / b648bd6549

reftable/reader: rename data structure to "table"

The `struct reftable_reader` subsystem encapsulates a table that has been read from the disk. As such, the current name of that structure is somewhat hard to understand as it only talks about the fact that we read something from disk, without really giving an indicator _what_ that is. Furthermore, this naming schema doesn't really fit well into how the other structures are named: `reftable_merged_table`, `reftable_stack`, `reftable_block` and `reftable_record` are all named after what they encapsulate. Rename the subsystem to `reftable_table`, which directly gives a hint that the data structure is about handling the individual tables part of the stack. While this change results in a lot of churn, it prepares for us exposing the APIs to third-party callers now that the reftable library is a standalone library that can be linked against by other projects. Signed-off-by: Patrick Steinhardt <ps@pks.im> Signed-off-by: Junio C Hamano <gitster@pobox.com>

Patrick Steinhardt committed Apr 7, 2025 at 15:16 UTC b648bd654947db06e5549d724f46d3660ac11e19
19 files changed +467 -467
Makefile
+2 -2
@@ -1374,10 +1374,10 @@ UNIT_TEST_PROGRAMS += t-reftable-basics
1374 UNIT_TEST_PROGRAMS += t-reftable-block
1375 UNIT_TEST_PROGRAMS += t-reftable-merged
1376 UNIT_TEST_PROGRAMS += t-reftable-pq
1377 -UNIT_TEST_PROGRAMS += t-reftable-reader
1377 UNIT_TEST_PROGRAMS += t-reftable-readwrite
1378 UNIT_TEST_PROGRAMS += t-reftable-record
1379 UNIT_TEST_PROGRAMS += t-reftable-stack
1380 +UNIT_TEST_PROGRAMS += t-reftable-table
1381 UNIT_TEST_PROGRAMS += t-trailer
1382 UNIT_TEST_PROGRAMS += t-urlmatch-normalization
1383 UNIT_TEST_PROGS = $(patsubst %,$(UNIT_TEST_BIN)/%$X,$(UNIT_TEST_PROGRAMS))
@@ -2729,10 +2729,10 @@ REFTABLE_OBJS += reftable/blocksource.o
2729 REFTABLE_OBJS += reftable/iter.o
2730 REFTABLE_OBJS += reftable/merged.o
2731 REFTABLE_OBJS += reftable/pq.o
2732 -REFTABLE_OBJS += reftable/reader.o
2732 REFTABLE_OBJS += reftable/record.o
2733 REFTABLE_OBJS += reftable/stack.o
2734 REFTABLE_OBJS += reftable/system.o
2735 +REFTABLE_OBJS += reftable/table.o
2736 REFTABLE_OBJS += reftable/tree.o
2737 REFTABLE_OBJS += reftable/writer.o
2738
meson.build
+1 -1
@@ -410,10 +410,10 @@ libgit_sources = [
410 'reftable/iter.c',
411 'reftable/merged.c',
412 'reftable/pq.c',
413 - 'reftable/reader.c',
413 'reftable/record.c',
414 'reftable/stack.c',
415 'reftable/system.c',
416 + 'reftable/table.c',
417 'reftable/tree.c',
418 'reftable/writer.c',
419 'remote.c',
reftable/iter.c
+5 -5
@@ -12,8 +12,8 @@
12
13 #include "block.h"
14 #include "constants.h"
15 -#include "reader.h"
15 #include "reftable-error.h"
16 +#include "table.h"
17
18 int iterator_seek(struct reftable_iterator *it, struct reftable_record *want)
19 {
@@ -130,8 +130,8 @@ static int indexed_table_ref_iter_next_block(struct indexed_table_ref_iter *it)
130 reftable_block_done(&it->block_reader.block);
131
132 off = it->offsets[it->offset_idx++];
133 - err = reader_init_block_reader(it->r, &it->block_reader, off,
134 - BLOCK_TYPE_REF);
133 + err = table_init_block_reader(it->table, &it->block_reader, off,
134 + BLOCK_TYPE_REF);
135 if (err < 0) {
136 return err;
137 }
@@ -181,7 +181,7 @@ static int indexed_table_ref_iter_next(void *p, struct reftable_record *rec)
181 }
182
183 int indexed_table_ref_iter_new(struct indexed_table_ref_iter **dest,
184 - struct reftable_reader *r, uint8_t *oid,
184 + struct reftable_table *t, uint8_t *oid,
185 int oid_len, uint64_t *offsets, int offset_len)
186 {
187 struct indexed_table_ref_iter empty = INDEXED_TABLE_REF_ITER_INIT;
@@ -195,7 +195,7 @@ int indexed_table_ref_iter_new(struct indexed_table_ref_iter **dest,
195 }
196
197 *itr = empty;
198 - itr->r = r;
198 + itr->table = t;
199
200 err = reftable_buf_add(&itr->oid, oid, oid_len);
201 if (err < 0)
reftable/iter.h
+2 -2
@@ -59,7 +59,7 @@ void iterator_from_filtering_ref_iterator(struct reftable_iterator *,
59 * but using the object index.
60 */
61 struct indexed_table_ref_iter {
62 - struct reftable_reader *r;
62 + struct reftable_table *table;
63 struct reftable_buf oid;
64
65 /* mutable */
@@ -83,7 +83,7 @@ void iterator_from_indexed_table_ref_iter(struct reftable_iterator *it,
83
84 /* Takes ownership of `offsets` */
85 int indexed_table_ref_iter_new(struct indexed_table_ref_iter **dest,
86 - struct reftable_reader *r, uint8_t *oid,
86 + struct reftable_table *t, uint8_t *oid,
87 int oid_len, uint64_t *offsets, int offset_len);
88
89 #endif
reftable/merged.c
+13 -13
@@ -11,11 +11,11 @@
11 #include "constants.h"
12 #include "iter.h"
13 #include "pq.h"
14 -#include "reader.h"
14 #include "record.h"
15 #include "reftable-merged.h"
16 #include "reftable-error.h"
17 #include "system.h"
18 +#include "table.h"
19
20 struct merged_subiter {
21 struct reftable_iterator iter;
@@ -192,7 +192,7 @@ static void iterator_from_merged_iter(struct reftable_iterator *it,
192 }
193
194 int reftable_merged_table_new(struct reftable_merged_table **dest,
195 - struct reftable_reader **readers, size_t n,
195 + struct reftable_table **tables, size_t n,
196 enum reftable_hash hash_id)
197 {
198 struct reftable_merged_table *m = NULL;
@@ -200,10 +200,10 @@ int reftable_merged_table_new(struct reftable_merged_table **dest,
200 uint64_t first_min = 0;
201
202 for (size_t i = 0; i < n; i++) {
203 - uint64_t min = reftable_reader_min_update_index(readers[i]);
204 - uint64_t max = reftable_reader_max_update_index(readers[i]);
203 + uint64_t min = reftable_table_min_update_index(tables[i]);
204 + uint64_t max = reftable_table_max_update_index(tables[i]);
205
206 - if (reftable_reader_hash_id(readers[i]) != hash_id) {
206 + if (reftable_table_hash_id(tables[i]) != hash_id) {
207 return REFTABLE_FORMAT_ERROR;
208 }
209 if (i == 0 || min < first_min) {
@@ -218,8 +218,8 @@ int reftable_merged_table_new(struct reftable_merged_table **dest,
218 if (!m)
219 return REFTABLE_OUT_OF_MEMORY_ERROR;
220
221 - m->readers = readers;
222 - m->readers_len = n;
221 + m->tables = tables;
222 + m->tables_len = n;
223 m->min = first_min;
224 m->max = last_max;
225 m->hash_id = hash_id;
@@ -254,20 +254,20 @@ int merged_table_init_iter(struct reftable_merged_table *mt,
254 struct merged_iter *mi = NULL;
255 int ret;
256
257 - if (mt->readers_len) {
258 - REFTABLE_CALLOC_ARRAY(subiters, mt->readers_len);
257 + if (mt->tables_len) {
258 + REFTABLE_CALLOC_ARRAY(subiters, mt->tables_len);
259 if (!subiters) {
260 ret = REFTABLE_OUT_OF_MEMORY_ERROR;
261 goto out;
262 }
263 }
264
265 - for (size_t i = 0; i < mt->readers_len; i++) {
265 + for (size_t i = 0; i < mt->tables_len; i++) {
266 ret = reftable_record_init(&subiters[i].rec, typ);
267 if (ret < 0)
268 goto out;
269
270 - ret = reader_init_iter(mt->readers[i], &subiters[i].iter, typ);
270 + ret = table_init_iter(mt->tables[i], &subiters[i].iter, typ);
271 if (ret < 0)
272 goto out;
273 }
@@ -280,14 +280,14 @@ int merged_table_init_iter(struct reftable_merged_table *mt,
280 mi->advance_index = -1;
281 mi->suppress_deletions = mt->suppress_deletions;
282 mi->subiters = subiters;
283 - mi->subiters_len = mt->readers_len;
283 + mi->subiters_len = mt->tables_len;
284
285 iterator_from_merged_iter(it, mi);
286 ret = 0;
287
288 out:
289 if (ret < 0) {
290 - for (size_t i = 0; subiters && i < mt->readers_len; i++) {
290 + for (size_t i = 0; subiters && i < mt->tables_len; i++) {
291 reftable_iterator_destroy(&subiters[i].iter);
292 reftable_record_release(&subiters[i].rec);
293 }
reftable/merged.h
+2 -2
@@ -13,8 +13,8 @@
13 #include "reftable-basics.h"
14
15 struct reftable_merged_table {
16 - struct reftable_reader **readers;
17 - size_t readers_len;
16 + struct reftable_table **tables;
17 + size_t tables_len;
18 enum reftable_hash hash_id;
19
20 /* If unset, produce deletions. This is useful for compaction. For the
reftable/reftable-merged.h
+3 -3
@@ -26,14 +26,14 @@
26 /* A merged table is implements seeking/iterating over a stack of tables. */
27 struct reftable_merged_table;
28
29 -struct reftable_reader;
29 +struct reftable_table;
30
31 /*
32 - * reftable_merged_table_new creates a new merged table. The readers must be
32 + * reftable_merged_table_new creates a new merged table. The tables must be
33 * kept alive as long as the merged table is still in use.
34 */
35 int reftable_merged_table_new(struct reftable_merged_table **dest,
36 - struct reftable_reader **readers, size_t n,
36 + struct reftable_table **tables, size_t n,
37 enum reftable_hash hash_id);
38
39 /* Initialize a merged table iterator for reading refs. */
reftable/reftable-reader.h deleted
-72
@@ -1,72 +0,0 @@
1 -/*
2 - * Copyright 2020 Google LLC
3 - *
4 - * Use of this source code is governed by a BSD-style
5 - * license that can be found in the LICENSE file or at
6 - * https://developers.google.com/open-source/licenses/bsd
7 - */
8 -
9 -#ifndef REFTABLE_READER_H
10 -#define REFTABLE_READER_H
11 -
12 -#include "reftable-iterator.h"
13 -#include "reftable-blocksource.h"
14 -
15 -/*
16 - * Reading single tables
17 - *
18 - * The follow routines are for reading single files. For an
19 - * application-level interface, skip ahead to struct
20 - * reftable_merged_table and struct reftable_stack.
21 - */
22 -
23 -/* The reader struct is a handle to an open reftable file. */
24 -struct reftable_reader;
25 -
26 -/* reftable_reader_new opens a reftable for reading. If successful,
27 - * returns 0 code and sets pp. The name is used for creating a
28 - * stack. Typically, it is the basename of the file. The block source
29 - * `src` is owned by the reader, and is closed on calling
30 - * reftable_reader_destroy(). On error, the block source `src` is
31 - * closed as well.
32 - */
33 -int reftable_reader_new(struct reftable_reader **pp,
34 - struct reftable_block_source *src, const char *name);
35 -
36 -/*
37 - * Manage the reference count of the reftable reader. A newly initialized
38 - * reader starts with a refcount of 1 and will be deleted once the refcount has
39 - * reached 0.
40 - *
41 - * This is required because readers may have longer lifetimes than the stack
42 - * they belong to. The stack may for example be reloaded while the old tables
43 - * are still being accessed by an iterator.
44 - */
45 -void reftable_reader_incref(struct reftable_reader *reader);
46 -void reftable_reader_decref(struct reftable_reader *reader);
47 -
48 -/* Initialize a reftable iterator for reading refs. */
49 -int reftable_reader_init_ref_iterator(struct reftable_reader *r,
50 - struct reftable_iterator *it);
51 -
52 -/* Initialize a reftable iterator for reading logs. */
53 -int reftable_reader_init_log_iterator(struct reftable_reader *r,
54 - struct reftable_iterator *it);
55 -
56 -/* returns the hash ID used in this table. */
57 -enum reftable_hash reftable_reader_hash_id(struct reftable_reader *r);
58 -
59 -/* return an iterator for the refs pointing to `oid`. */
60 -int reftable_reader_refs_for(struct reftable_reader *r,
61 - struct reftable_iterator *it, uint8_t *oid);
62 -
63 -/* return the max_update_index for a table */
64 -uint64_t reftable_reader_max_update_index(struct reftable_reader *r);
65 -
66 -/* return the min_update_index for a table */
67 -uint64_t reftable_reader_min_update_index(struct reftable_reader *r);
68 -
69 -/* print blocks onto stdout for debugging. */
70 -int reftable_reader_print_blocks(const char *tablename);
71 -
72 -#endif
reftable/reftable-table.h new
+72
@@ -0,0 +1,72 @@
1 +/*
2 + * Copyright 2020 Google LLC
3 + *
4 + * Use of this source code is governed by a BSD-style
5 + * license that can be found in the LICENSE file or at
6 + * https://developers.google.com/open-source/licenses/bsd
7 + */
8 +
9 +#ifndef REFTABLE_TABLE_H
10 +#define REFTABLE_TABLE_H
11 +
12 +#include "reftable-iterator.h"
13 +#include "reftable-blocksource.h"
14 +
15 +/*
16 + * Reading single tables
17 + *
18 + * The follow routines are for reading single files. For an
19 + * application-level interface, skip ahead to struct
20 + * reftable_merged_table and struct reftable_stack.
21 + */
22 +
23 +/* The table struct is a handle to an open reftable file. */
24 +struct reftable_table;
25 +
26 +/* reftable_table_new opens a reftable for reading. If successful,
27 + * returns 0 code and sets pp. The name is used for creating a
28 + * stack. Typically, it is the basename of the file. The block source
29 + * `src` is owned by the table, and is closed on calling
30 + * reftable_table_destroy(). On error, the block source `src` is
31 + * closed as well.
32 + */
33 +int reftable_table_new(struct reftable_table **out,
34 + struct reftable_block_source *src, const char *name);
35 +
36 +/*
37 + * Manage the reference count of the reftable table. A newly initialized
38 + * table starts with a refcount of 1 and will be deleted once the refcount has
39 + * reached 0.
40 + *
41 + * This is required because tables may have longer lifetimes than the stack
42 + * they belong to. The stack may for example be reloaded while the old tables
43 + * are still being accessed by an iterator.
44 + */
45 +void reftable_table_incref(struct reftable_table *table);
46 +void reftable_table_decref(struct reftable_table *table);
47 +
48 +/* Initialize a reftable iterator for reading refs. */
49 +int reftable_table_init_ref_iterator(struct reftable_table *t,
50 + struct reftable_iterator *it);
51 +
52 +/* Initialize a reftable iterator for reading logs. */
53 +int reftable_table_init_log_iterator(struct reftable_table *t,
54 + struct reftable_iterator *it);
55 +
56 +/* returns the hash ID used in this table. */
57 +enum reftable_hash reftable_table_hash_id(struct reftable_table *t);
58 +
59 +/* return an iterator for the refs pointing to `oid`. */
60 +int reftable_table_refs_for(struct reftable_table *t,
61 + struct reftable_iterator *it, uint8_t *oid);
62 +
63 +/* return the max_update_index for a table */
64 +uint64_t reftable_table_max_update_index(struct reftable_table *t);
65 +
66 +/* return the min_update_index for a table */
67 +uint64_t reftable_table_min_update_index(struct reftable_table *t);
68 +
69 +/* print blocks onto stdout for debugging. */
70 +int reftable_table_print_blocks(const char *tablename);
71 +
72 +#endif
reftable/stack.c
+84 -84
@@ -11,10 +11,10 @@
11 #include "system.h"
12 #include "constants.h"
13 #include "merged.h"
14 -#include "reader.h"
14 #include "reftable-error.h"
15 #include "reftable-record.h"
16 #include "reftable-merged.h"
17 +#include "table.h"
18 #include "writer.h"
19
20 static int stack_try_add(struct reftable_stack *st,
@@ -248,11 +248,11 @@ void reftable_stack_destroy(struct reftable_stack *st)
248 REFTABLE_FREE_AND_NULL(names);
249 }
250
251 - if (st->readers) {
251 + if (st->tables) {
252 struct reftable_buf filename = REFTABLE_BUF_INIT;
253
254 - for (size_t i = 0; i < st->readers_len; i++) {
255 - const char *name = reader_name(st->readers[i]);
254 + for (size_t i = 0; i < st->tables_len; i++) {
255 + const char *name = reftable_table_name(st->tables[i]);
256 int try_unlinking = 1;
257
258 reftable_buf_reset(&filename);
@@ -260,7 +260,7 @@ void reftable_stack_destroy(struct reftable_stack *st)
260 if (stack_filename(&filename, st, name) < 0)
261 try_unlinking = 0;
262 }
263 - reftable_reader_decref(st->readers[i]);
263 + reftable_table_decref(st->tables[i]);
264
265 if (try_unlinking && filename.len) {
266 /* On Windows, can only unlink after closing. */
@@ -269,8 +269,8 @@ void reftable_stack_destroy(struct reftable_stack *st)
269 }
270
271 reftable_buf_release(&filename);
272 - st->readers_len = 0;
273 - REFTABLE_FREE_AND_NULL(st->readers);
272 + st->tables_len = 0;
273 + REFTABLE_FREE_AND_NULL(st->tables);
274 }
275
276 if (st->list_fd >= 0) {
@@ -284,14 +284,14 @@ void reftable_stack_destroy(struct reftable_stack *st)
284 free_names(names);
285 }
286
287 -static struct reftable_reader **stack_copy_readers(struct reftable_stack *st,
288 - size_t cur_len)
287 +static struct reftable_table **stack_copy_tables(struct reftable_stack *st,
288 + size_t cur_len)
289 {
290 - struct reftable_reader **cur = reftable_calloc(cur_len, sizeof(*cur));
290 + struct reftable_table **cur = reftable_calloc(cur_len, sizeof(*cur));
291 if (!cur)
292 return NULL;
293 for (size_t i = 0; i < cur_len; i++)
294 - cur[i] = st->readers[i];
294 + cur[i] = st->tables[i];
295 return cur;
296 }
297
@@ -299,19 +299,19 @@ static int reftable_stack_reload_once(struct reftable_stack *st,
299 const char **names,
300 int reuse_open)
301 {
302 - size_t cur_len = !st->merged ? 0 : st->merged->readers_len;
303 - struct reftable_reader **cur = NULL;
304 - struct reftable_reader **reused = NULL;
305 - struct reftable_reader **new_readers = NULL;
302 + size_t cur_len = !st->merged ? 0 : st->merged->tables_len;
303 + struct reftable_table **cur = NULL;
304 + struct reftable_table **reused = NULL;
305 + struct reftable_table **new_tables = NULL;
306 size_t reused_len = 0, reused_alloc = 0, names_len;
307 - size_t new_readers_len = 0;
307 + size_t new_tables_len = 0;
308 struct reftable_merged_table *new_merged = NULL;
309 struct reftable_buf table_path = REFTABLE_BUF_INIT;
310 int err = 0;
311 size_t i;
312
313 if (cur_len) {
314 - cur = stack_copy_readers(st, cur_len);
314 + cur = stack_copy_tables(st, cur_len);
315 if (!cur) {
316 err = REFTABLE_OUT_OF_MEMORY_ERROR;
317 goto done;
@@ -321,28 +321,28 @@ static int reftable_stack_reload_once(struct reftable_stack *st,
321 names_len = names_length(names);
322
323 if (names_len) {
324 - new_readers = reftable_calloc(names_len, sizeof(*new_readers));
325 - if (!new_readers) {
324 + new_tables = reftable_calloc(names_len, sizeof(*new_tables));
325 + if (!new_tables) {
326 err = REFTABLE_OUT_OF_MEMORY_ERROR;
327 goto done;
328 }
329 }
330
331 while (*names) {
332 - struct reftable_reader *rd = NULL;
332 + struct reftable_table *table = NULL;
333 const char *name = *names++;
334
335 /* this is linear; we assume compaction keeps the number of
336 tables under control so this is not quadratic. */
337 for (i = 0; reuse_open && i < cur_len; i++) {
338 if (cur[i] && 0 == strcmp(cur[i]->name, name)) {
339 - rd = cur[i];
339 + table = cur[i];
340 cur[i] = NULL;
341
342 /*
343 * When reloading the stack fails, we end up
344 - * releasing all new readers. This also
345 - * includes the reused readers, even though
344 + * releasing all new tables. This also
345 + * includes the reused tables, even though
346 * they are still in used by the old stack. We
347 * thus need to keep them alive here, which we
348 * do by bumping their refcount.
@@ -354,13 +354,13 @@ static int reftable_stack_reload_once(struct reftable_stack *st,
354 err = REFTABLE_OUT_OF_MEMORY_ERROR;
355 goto done;
356 }
357 - reused[reused_len++] = rd;
358 - reftable_reader_incref(rd);
357 + reused[reused_len++] = table;
358 + reftable_table_incref(table);
359 break;
360 }
361 }
362
363 - if (!rd) {
363 + if (!table) {
364 struct reftable_block_source src = { NULL };
365
366 err = stack_filename(&table_path, st, name);
@@ -372,36 +372,36 @@ static int reftable_stack_reload_once(struct reftable_stack *st,
372 if (err < 0)
373 goto done;
374
375 - err = reftable_reader_new(&rd, &src, name);
375 + err = reftable_table_new(&table, &src, name);
376 if (err < 0)
377 goto done;
378 }
379
380 - new_readers[new_readers_len] = rd;
381 - new_readers_len++;
380 + new_tables[new_tables_len] = table;
381 + new_tables_len++;
382 }
383
384 /* success! */
385 - err = reftable_merged_table_new(&new_merged, new_readers,
386 - new_readers_len, st->opts.hash_id);
385 + err = reftable_merged_table_new(&new_merged, new_tables,
386 + new_tables_len, st->opts.hash_id);
387 if (err < 0)
388 goto done;
389
390 /*
391 - * Close the old, non-reused readers and proactively try to unlink
391 + * Close the old, non-reused tables and proactively try to unlink
392 * them. This is done for systems like Windows, where the underlying
393 - * file of such an open reader wouldn't have been possible to be
393 + * file of such an open table wouldn't have been possible to be
394 * unlinked by the compacting process.
395 */
396 for (i = 0; i < cur_len; i++) {
397 if (cur[i]) {
398 - const char *name = reader_name(cur[i]);
398 + const char *name = reftable_table_name(cur[i]);
399
400 err = stack_filename(&table_path, st, name);
401 if (err < 0)
402 goto done;
403
404 - reftable_reader_decref(cur[i]);
404 + reftable_table_decref(cur[i]);
405 unlink(table_path.buf);
406 }
407 }
@@ -412,25 +412,25 @@ static int reftable_stack_reload_once(struct reftable_stack *st,
412 new_merged->suppress_deletions = 1;
413 st->merged = new_merged;
414
415 - if (st->readers)
416 - reftable_free(st->readers);
417 - st->readers = new_readers;
418 - st->readers_len = new_readers_len;
419 - new_readers = NULL;
420 - new_readers_len = 0;
415 + if (st->tables)
416 + reftable_free(st->tables);
417 + st->tables = new_tables;
418 + st->tables_len = new_tables_len;
419 + new_tables = NULL;
420 + new_tables_len = 0;
421
422 /*
423 - * Decrement the refcount of reused readers again. This only needs to
423 + * Decrement the refcount of reused tables again. This only needs to
424 * happen on the successful case, because on the unsuccessful one we
425 - * decrement their refcount via `new_readers`.
425 + * decrement their refcount via `new_tables`.
426 */
427 for (i = 0; i < reused_len; i++)
428 - reftable_reader_decref(reused[i]);
428 + reftable_table_decref(reused[i]);
429
430 done:
431 - for (i = 0; i < new_readers_len; i++)
432 - reftable_reader_decref(new_readers[i]);
433 - reftable_free(new_readers);
431 + for (i = 0; i < new_tables_len; i++)
432 + reftable_table_decref(new_tables[i]);
433 + reftable_free(new_tables);
434 reftable_free(reused);
435 reftable_free(cur);
436 reftable_buf_release(&table_path);
@@ -615,10 +615,10 @@ static int stack_uptodate(struct reftable_stack *st)
615 /*
616 * It's fine for "tables.list" to not exist. In that
617 * case, we have to refresh when the loaded stack has
618 - * any readers.
618 + * any tables.
619 */
620 if (errno == ENOENT)
621 - return !!st->readers_len;
621 + return !!st->tables_len;
622 return REFTABLE_IO_ERROR;
623 }
624
@@ -637,19 +637,19 @@ static int stack_uptodate(struct reftable_stack *st)
637 if (err < 0)
638 return err;
639
640 - for (size_t i = 0; i < st->readers_len; i++) {
640 + for (size_t i = 0; i < st->tables_len; i++) {
641 if (!names[i]) {
642 err = 1;
643 goto done;
644 }
645
646 - if (strcmp(st->readers[i]->name, names[i])) {
646 + if (strcmp(st->tables[i]->name, names[i])) {
647 err = 1;
648 goto done;
649 }
650 }
651
652 - if (names[st->merged->readers_len]) {
652 + if (names[st->merged->tables_len]) {
653 err = 1;
654 goto done;
655 }
@@ -792,8 +792,8 @@ int reftable_addition_commit(struct reftable_addition *add)
792 if (add->new_tables_len == 0)
793 goto done;
794
795 - for (i = 0; i < add->stack->merged->readers_len; i++) {
796 - if ((err = reftable_buf_addstr(&table_list, add->stack->readers[i]->name)) < 0 ||
795 + for (i = 0; i < add->stack->merged->tables_len; i++) {
796 + if ((err = reftable_buf_addstr(&table_list, add->stack->tables[i]->name)) < 0 ||
797 (err = reftable_buf_addstr(&table_list, "\n")) < 0)
798 goto done;
799 }
@@ -1000,9 +1000,9 @@ done:
1000
1001 uint64_t reftable_stack_next_update_index(struct reftable_stack *st)
1002 {
1003 - int sz = st->merged->readers_len;
1003 + int sz = st->merged->tables_len;
1004 if (sz > 0)
1005 - return reftable_reader_max_update_index(st->readers[sz - 1]) +
1005 + return reftable_table_max_update_index(st->tables[sz - 1]) +
1006 1;
1007 return 1;
1008 }
@@ -1021,8 +1021,8 @@ static int stack_compact_locked(struct reftable_stack *st,
1021 struct reftable_tmpfile tab_file = REFTABLE_TMPFILE_INIT;
1022 int err = 0;
1023
1024 - err = format_name(&next_name, reftable_reader_min_update_index(st->readers[first]),
1025 - reftable_reader_max_update_index(st->readers[last]));
1024 + err = format_name(&next_name, reftable_table_min_update_index(st->tables[first]),
1025 + reftable_table_max_update_index(st->tables[last]));
1026 if (err < 0)
1027 goto done;
1028
@@ -1087,13 +1087,13 @@ static int stack_write_compact(struct reftable_stack *st,
1087 int err = 0;
1088
1089 for (size_t i = first; i <= last; i++)
1090 - st->stats.bytes += st->readers[i]->size;
1091 - err = reftable_writer_set_limits(wr, st->readers[first]->min_update_index,
1092 - st->readers[last]->max_update_index);
1090 + st->stats.bytes += st->tables[i]->size;
1091 + err = reftable_writer_set_limits(wr, st->tables[first]->min_update_index,
1092 + st->tables[last]->max_update_index);
1093 if (err < 0)
1094 goto done;
1095
1096 - err = reftable_merged_table_new(&mt, st->readers + first, subtabs_len,
1096 + err = reftable_merged_table_new(&mt, st->tables + first, subtabs_len,
1097 st->opts.hash_id);
1098 if (err < 0)
1099 goto done;
@@ -1250,7 +1250,7 @@ static int stack_compact_range(struct reftable_stack *st,
1250 table_locks[i] = REFTABLE_FLOCK_INIT;
1251
1252 for (i = last + 1; i > first; i--) {
1253 - err = stack_filename(&table_name, st, reader_name(st->readers[i - 1]));
1253 + err = stack_filename(&table_name, st, reftable_table_name(st->tables[i - 1]));
1254 if (err < 0)
1255 goto done;
1256
@@ -1376,7 +1376,7 @@ static int stack_compact_range(struct reftable_stack *st,
1376 * compacted in the updated "tables.list" file.
1377 */
1378 for (size_t i = 0; names[i]; i++) {
1379 - if (strcmp(names[i], st->readers[first]->name))
1379 + if (strcmp(names[i], st->tables[first]->name))
1380 continue;
1381
1382 /*
@@ -1386,8 +1386,8 @@ static int stack_compact_range(struct reftable_stack *st,
1386 * have compacted them.
1387 */
1388 for (size_t j = 1; j < last - first + 1; j++) {
1389 - const char *old = first + j < st->merged->readers_len ?
1390 - st->readers[first + j]->name : NULL;
1389 + const char *old = first + j < st->merged->tables_len ?
1390 + st->tables[first + j]->name : NULL;
1391 const char *new = names[i + j];
1392
1393 /*
@@ -1427,16 +1427,16 @@ static int stack_compact_range(struct reftable_stack *st,
1427 * `fd_read_lines()` uses a `NULL` sentinel to indicate that
1428 * the array is at its end. As we use `free_names()` to free
1429 * the array, we need to include this sentinel value here and
1430 - * thus have to allocate `readers_len + 1` many entries.
1430 + * thus have to allocate `tables_len + 1` many entries.
1431 */
1432 - REFTABLE_CALLOC_ARRAY(names, st->merged->readers_len + 1);
1432 + REFTABLE_CALLOC_ARRAY(names, st->merged->tables_len + 1);
1433 if (!names) {
1434 err = REFTABLE_OUT_OF_MEMORY_ERROR;
1435 goto done;
1436 }
1437
1438 - for (size_t i = 0; i < st->merged->readers_len; i++) {
1439 - names[i] = reftable_strdup(st->readers[i]->name);
1438 + for (size_t i = 0; i < st->merged->tables_len; i++) {
1439 + names[i] = reftable_strdup(st->tables[i]->name);
1440 if (!names[i]) {
1441 err = REFTABLE_OUT_OF_MEMORY_ERROR;
1442 goto done;
@@ -1451,8 +1451,8 @@ static int stack_compact_range(struct reftable_stack *st,
1451 * it into place now.
1452 */
1453 if (!is_empty_table) {
1454 - err = format_name(&new_table_name, st->readers[first]->min_update_index,
1455 - st->readers[last]->max_update_index);
1454 + err = format_name(&new_table_name, st->tables[first]->min_update_index,
1455 + st->tables[last]->max_update_index);
1456 if (err < 0)
1457 goto done;
1458
@@ -1559,7 +1559,7 @@ done:
1559 int reftable_stack_compact_all(struct reftable_stack *st,
1560 struct reftable_log_expiry_config *config)
1561 {
1562 - size_t last = st->merged->readers_len ? st->merged->readers_len - 1 : 0;
1562 + size_t last = st->merged->tables_len ? st->merged->tables_len - 1 : 0;
1563 return stack_compact_range(st, 0, last, config, 0);
1564 }
1565
@@ -1650,12 +1650,12 @@ static uint64_t *stack_table_sizes_for_compaction(struct reftable_stack *st)
1650 int overhead = header_size(version) - 1;
1651 uint64_t *sizes;
1652
1653 - REFTABLE_CALLOC_ARRAY(sizes, st->merged->readers_len);
1653 + REFTABLE_CALLOC_ARRAY(sizes, st->merged->tables_len);
1654 if (!sizes)
1655 return NULL;
1656
1657 - for (size_t i = 0; i < st->merged->readers_len; i++)
1658 - sizes[i] = st->readers[i]->size - overhead;
1657 + for (size_t i = 0; i < st->merged->tables_len; i++)
1658 + sizes[i] = st->tables[i]->size - overhead;
1659
1660 return sizes;
1661 }
@@ -1665,14 +1665,14 @@ int reftable_stack_auto_compact(struct reftable_stack *st)
1665 struct segment seg;
1666 uint64_t *sizes;
1667
1668 - if (st->merged->readers_len < 2)
1668 + if (st->merged->tables_len < 2)
1669 return 0;
1670
1671 sizes = stack_table_sizes_for_compaction(st);
1672 if (!sizes)
1673 return REFTABLE_OUT_OF_MEMORY_ERROR;
1674
1675 - seg = suggest_compaction_segment(sizes, st->merged->readers_len,
1675 + seg = suggest_compaction_segment(sizes, st->merged->tables_len,
1676 st->opts.auto_compaction_factor);
1677 reftable_free(sizes);
1678
@@ -1763,7 +1763,7 @@ static void remove_maybe_stale_table(struct reftable_stack *st, uint64_t max,
1763 int err = 0;
1764 uint64_t update_idx = 0;
1765 struct reftable_block_source src = { NULL };
1766 - struct reftable_reader *rd = NULL;
1766 + struct reftable_table *table = NULL;
1767 struct reftable_buf table_path = REFTABLE_BUF_INIT;
1768
1769 err = stack_filename(&table_path, st, name);
@@ -1774,12 +1774,12 @@ static void remove_maybe_stale_table(struct reftable_stack *st, uint64_t max,
1774 if (err < 0)
1775 goto done;
1776
1777 - err = reftable_reader_new(&rd, &src, name);
1777 + err = reftable_table_new(&table, &src, name);
1778 if (err < 0)
1779 goto done;
1780
1781 - update_idx = reftable_reader_max_update_index(rd);
1782 - reftable_reader_decref(rd);
1781 + update_idx = reftable_table_max_update_index(table);
1782 + reftable_table_decref(table);
1783
1784 if (update_idx <= max) {
1785 unlink(table_path.buf);
@@ -1803,8 +1803,8 @@ static int reftable_stack_clean_locked(struct reftable_stack *st)
1803 if (!is_table_name(d->d_name))
1804 continue;
1805
1806 - for (size_t i = 0; !found && i < st->readers_len; i++)
1807 - found = !strcmp(reader_name(st->readers[i]), d->d_name);
1806 + for (size_t i = 0; !found && i < st->tables_len; i++)
1807 + found = !strcmp(reftable_table_name(st->tables[i]), d->d_name);
1808 if (found)
1809 continue;
1810
reftable/stack.h
+2 -2
@@ -22,8 +22,8 @@ struct reftable_stack {
22
23 struct reftable_write_options opts;
24
25 - struct reftable_reader **readers;
26 - size_t readers_len;
25 + struct reftable_table **tables;
26 + size_t tables_len;
27 struct reftable_merged_table *merged;
28 struct reftable_compaction_stats stats;
29 };
reftable/table.c renamed
+127 -127
@@ -6,7 +6,7 @@
6 * https://developers.google.com/open-source/licenses/bsd
7 */
8
9 -#include "reader.h"
9 +#include "table.h"
10
11 #include "system.h"
12 #include "block.h"
@@ -39,48 +39,48 @@ void block_source_close(struct reftable_block_source *source)
39 source->ops = NULL;
40 }
41
42 -static struct reftable_reader_offsets *
43 -reader_offsets_for(struct reftable_reader *r, uint8_t typ)
42 +static struct reftable_table_offsets *
43 +table_offsets_for(struct reftable_table *t, uint8_t typ)
44 {
45 switch (typ) {
46 case BLOCK_TYPE_REF:
47 - return &r->ref_offsets;
47 + return &t->ref_offsets;
48 case BLOCK_TYPE_LOG:
49 - return &r->log_offsets;
49 + return &t->log_offsets;
50 case BLOCK_TYPE_OBJ:
51 - return &r->obj_offsets;
51 + return &t->obj_offsets;
52 }
53 abort();
54 }
55
56 -static int reader_get_block(struct reftable_reader *r,
57 - struct reftable_block *dest, uint64_t off,
58 - uint32_t sz)
56 +static int table_get_block(struct reftable_table *t,
57 + struct reftable_block *dest, uint64_t off,
58 + uint32_t sz)
59 {
60 ssize_t bytes_read;
61 - if (off >= r->size)
61 + if (off >= t->size)
62 return 0;
63 - if (off + sz > r->size)
64 - sz = r->size - off;
63 + if (off + sz > t->size)
64 + sz = t->size - off;
65
66 - bytes_read = block_source_read_block(&r->source, dest, off, sz);
66 + bytes_read = block_source_read_block(&t->source, dest, off, sz);
67 if (bytes_read < 0)
68 return (int)bytes_read;
69
70 return 0;
71 }
72
73 -enum reftable_hash reftable_reader_hash_id(struct reftable_reader *r)
73 +enum reftable_hash reftable_table_hash_id(struct reftable_table *t)
74 {
75 - return r->hash_id;
75 + return t->hash_id;
76 }
77
78 -const char *reader_name(struct reftable_reader *r)
78 +const char *reftable_table_name(struct reftable_table *t)
79 {
80 - return r->name;
80 + return t->name;
81 }
82
83 -static int parse_footer(struct reftable_reader *r, uint8_t *footer,
83 +static int parse_footer(struct reftable_table *t, uint8_t *footer,
84 uint8_t *header)
85 {
86 uint8_t *f = footer;
@@ -95,29 +95,29 @@ static int parse_footer(struct reftable_reader *r, uint8_t *footer,
95 }
96 f += 4;
97
98 - if (memcmp(footer, header, header_size(r->version))) {
98 + if (memcmp(footer, header, header_size(t->version))) {
99 err = REFTABLE_FORMAT_ERROR;
100 goto done;
101 }
102
103 f++;
104 - r->block_size = reftable_get_be24(f);
104 + t->block_size = reftable_get_be24(f);
105
106 f += 3;
107 - r->min_update_index = reftable_get_be64(f);
107 + t->min_update_index = reftable_get_be64(f);
108 f += 8;
109 - r->max_update_index = reftable_get_be64(f);
109 + t->max_update_index = reftable_get_be64(f);
110 f += 8;
111
112 - if (r->version == 1) {
113 - r->hash_id = REFTABLE_HASH_SHA1;
112 + if (t->version == 1) {
113 + t->hash_id = REFTABLE_HASH_SHA1;
114 } else {
115 switch (reftable_get_be32(f)) {
116 case REFTABLE_FORMAT_ID_SHA1:
117 - r->hash_id = REFTABLE_HASH_SHA1;
117 + t->hash_id = REFTABLE_HASH_SHA1;
118 break;
119 case REFTABLE_FORMAT_ID_SHA256:
120 - r->hash_id = REFTABLE_HASH_SHA256;
120 + t->hash_id = REFTABLE_HASH_SHA256;
121 break;
122 default:
123 err = REFTABLE_FORMAT_ERROR;
@@ -127,20 +127,20 @@ static int parse_footer(struct reftable_reader *r, uint8_t *footer,
127 f += 4;
128 }
129
130 - r->ref_offsets.index_offset = reftable_get_be64(f);
130 + t->ref_offsets.index_offset = reftable_get_be64(f);
131 f += 8;
132
133 - r->obj_offsets.offset = reftable_get_be64(f);
133 + t->obj_offsets.offset = reftable_get_be64(f);
134 f += 8;
135
136 - r->object_id_len = r->obj_offsets.offset & ((1 << 5) - 1);
137 - r->obj_offsets.offset >>= 5;
136 + t->object_id_len = t->obj_offsets.offset & ((1 << 5) - 1);
137 + t->obj_offsets.offset >>= 5;
138
139 - r->obj_offsets.index_offset = reftable_get_be64(f);
139 + t->obj_offsets.index_offset = reftable_get_be64(f);
140 f += 8;
141 - r->log_offsets.offset = reftable_get_be64(f);
141 + t->log_offsets.offset = reftable_get_be64(f);
142 f += 8;
143 - r->log_offsets.index_offset = reftable_get_be64(f);
143 + t->log_offsets.index_offset = reftable_get_be64(f);
144 f += 8;
145
146 computed_crc = crc32(0, footer, f - footer);
@@ -151,13 +151,13 @@ static int parse_footer(struct reftable_reader *r, uint8_t *footer,
151 goto done;
152 }
153
154 - first_block_typ = header[header_size(r->version)];
155 - r->ref_offsets.is_present = (first_block_typ == BLOCK_TYPE_REF);
156 - r->ref_offsets.offset = 0;
157 - r->log_offsets.is_present = (first_block_typ == BLOCK_TYPE_LOG ||
158 - r->log_offsets.offset > 0);
159 - r->obj_offsets.is_present = r->obj_offsets.offset > 0;
160 - if (r->obj_offsets.is_present && !r->object_id_len) {
154 + first_block_typ = header[header_size(t->version)];
155 + t->ref_offsets.is_present = (first_block_typ == BLOCK_TYPE_REF);
156 + t->ref_offsets.offset = 0;
157 + t->log_offsets.is_present = (first_block_typ == BLOCK_TYPE_LOG ||
158 + t->log_offsets.offset > 0);
159 + t->obj_offsets.is_present = t->obj_offsets.offset > 0;
160 + if (t->obj_offsets.is_present && !t->object_id_len) {
161 err = REFTABLE_FORMAT_ERROR;
162 goto done;
163 }
@@ -168,7 +168,7 @@ done:
168 }
169
170 struct table_iter {
171 - struct reftable_reader *r;
171 + struct reftable_table *table;
172 uint8_t typ;
173 uint64_t block_off;
174 struct block_reader br;
@@ -176,12 +176,12 @@ struct table_iter {
176 int is_finished;
177 };
178
179 -static int table_iter_init(struct table_iter *ti, struct reftable_reader *r)
179 +static int table_iter_init(struct table_iter *ti, struct reftable_table *t)
180 {
181 struct block_iter bi = BLOCK_ITER_INIT;
182 memset(ti, 0, sizeof(*ti));
183 - reftable_reader_incref(r);
184 - ti->r = r;
183 + reftable_table_incref(t);
184 + ti->table = t;
185 ti->bi = bi;
186 return 0;
187 }
@@ -191,7 +191,7 @@ static int table_iter_next_in_block(struct table_iter *ti,
191 {
192 int res = block_iter_next(&ti->bi, rec);
193 if (res == 0 && reftable_record_type(rec) == BLOCK_TYPE_REF) {
194 - rec->u.ref.update_index += ti->r->min_update_index;
194 + rec->u.ref.update_index += ti->table->min_update_index;
195 }
196
197 return res;
@@ -219,26 +219,26 @@ static int32_t extract_block_size(uint8_t *data, uint8_t *typ, uint64_t off,
219 return result;
220 }
221
222 -int reader_init_block_reader(struct reftable_reader *r, struct block_reader *br,
223 - uint64_t next_off, uint8_t want_typ)
222 +int table_init_block_reader(struct reftable_table *t, struct block_reader *br,
223 + uint64_t next_off, uint8_t want_typ)
224 {
225 - int32_t guess_block_size = r->block_size ? r->block_size :
225 + int32_t guess_block_size = t->block_size ? t->block_size :
226 DEFAULT_BLOCK_SIZE;
227 struct reftable_block block = { NULL };
228 uint8_t block_typ = 0;
229 int err = 0;
230 - uint32_t header_off = next_off ? 0 : header_size(r->version);
230 + uint32_t header_off = next_off ? 0 : header_size(t->version);
231 int32_t block_size = 0;
232
233 - if (next_off >= r->size)
233 + if (next_off >= t->size)
234 return 1;
235
236 - err = reader_get_block(r, &block, next_off, guess_block_size);
236 + err = table_get_block(t, &block, next_off, guess_block_size);
237 if (err < 0)
238 goto done;
239
240 block_size = extract_block_size(block.data, &block_typ, next_off,
241 - r->version);
241 + t->version);
242 if (block_size < 0) {
243 err = block_size;
244 goto done;
@@ -250,14 +250,14 @@ int reader_init_block_reader(struct reftable_reader *r, struct block_reader *br,
250
251 if (block_size > guess_block_size) {
252 reftable_block_done(&block);
253 - err = reader_get_block(r, &block, next_off, block_size);
253 + err = table_get_block(t, &block, next_off, block_size);
254 if (err < 0) {
255 goto done;
256 }
257 }
258
259 - err = block_reader_init(br, &block, header_off, r->block_size,
260 - hash_size(r->hash_id));
259 + err = block_reader_init(br, &block, header_off, t->block_size,
260 + hash_size(t->hash_id));
261 done:
262 reftable_block_done(&block);
263
@@ -268,7 +268,7 @@ static void table_iter_close(struct table_iter *ti)
268 {
269 table_iter_block_done(ti);
270 block_iter_close(&ti->bi);
271 - reftable_reader_decref(ti->r);
271 + reftable_table_decref(ti->table);
272 }
273
274 static int table_iter_next_block(struct table_iter *ti)
@@ -276,7 +276,7 @@ static int table_iter_next_block(struct table_iter *ti)
276 uint64_t next_block_off = ti->block_off + ti->br.full_block_size;
277 int err;
278
279 - err = reader_init_block_reader(ti->r, &ti->br, next_block_off, ti->typ);
279 + err = table_init_block_reader(ti->table, &ti->br, next_block_off, ti->typ);
280 if (err > 0)
281 ti->is_finished = 1;
282 if (err)
@@ -326,7 +326,7 @@ static int table_iter_seek_to(struct table_iter *ti, uint64_t off, uint8_t typ)
326 {
327 int err;
328
329 - err = reader_init_block_reader(ti->r, &ti->br, off, typ);
329 + err = table_init_block_reader(ti->table, &ti->br, off, typ);
330 if (err != 0)
331 return err;
332
@@ -339,7 +339,7 @@ static int table_iter_seek_to(struct table_iter *ti, uint64_t off, uint8_t typ)
339
340 static int table_iter_seek_start(struct table_iter *ti, uint8_t typ, int index)
341 {
342 - struct reftable_reader_offsets *offs = reader_offsets_for(ti->r, typ);
342 + struct reftable_table_offsets *offs = table_offsets_for(ti->table, typ);
343 uint64_t off = offs->offset;
344 if (index) {
345 off = offs->index_offset;
@@ -518,7 +518,7 @@ static int table_iter_seek(struct table_iter *ti,
518 struct reftable_record *want)
519 {
520 uint8_t typ = reftable_record_type(want);
521 - struct reftable_reader_offsets *offs = reader_offsets_for(ti->r, typ);
521 + struct reftable_table_offsets *offs = table_offsets_for(ti->table, typ);
522 int err;
523
524 err = table_iter_seek_start(ti, reftable_record_type(want),
@@ -566,11 +566,11 @@ static void iterator_from_table_iter(struct reftable_iterator *it,
566 it->ops = &table_iter_vtable;
567 }
568
569 -int reader_init_iter(struct reftable_reader *r,
570 - struct reftable_iterator *it,
571 - uint8_t typ)
569 +int table_init_iter(struct reftable_table *t,
570 + struct reftable_iterator *it,
571 + uint8_t typ)
572 {
573 - struct reftable_reader_offsets *offs = reader_offsets_for(r, typ);
573 + struct reftable_table_offsets *offs = table_offsets_for(t, typ);
574
575 if (offs->is_present) {
576 struct table_iter *ti;
@@ -578,7 +578,7 @@ int reader_init_iter(struct reftable_reader *r,
578 if (!ti)
579 return REFTABLE_OUT_OF_MEMORY_ERROR;
580
581 - table_iter_init(ti, r);
581 + table_iter_init(ti, t);
582 iterator_from_table_iter(it, ti);
583 } else {
584 iterator_set_empty(it);
@@ -587,31 +587,31 @@ int reader_init_iter(struct reftable_reader *r,
587 return 0;
588 }
589
590 -int reftable_reader_init_ref_iterator(struct reftable_reader *r,
591 - struct reftable_iterator *it)
590 +int reftable_table_init_ref_iterator(struct reftable_table *t,
591 + struct reftable_iterator *it)
592 {
593 - return reader_init_iter(r, it, BLOCK_TYPE_REF);
593 + return table_init_iter(t, it, BLOCK_TYPE_REF);
594 }
595
596 -int reftable_reader_init_log_iterator(struct reftable_reader *r,
597 - struct reftable_iterator *it)
596 +int reftable_table_init_log_iterator(struct reftable_table *t,
597 + struct reftable_iterator *it)
598 {
599 - return reader_init_iter(r, it, BLOCK_TYPE_LOG);
599 + return table_init_iter(t, it, BLOCK_TYPE_LOG);
600 }
601
602 -int reftable_reader_new(struct reftable_reader **out,
603 - struct reftable_block_source *source, char const *name)
602 +int reftable_table_new(struct reftable_table **out,
603 + struct reftable_block_source *source, char const *name)
604 {
605 struct reftable_block footer = { 0 };
606 struct reftable_block header = { 0 };
607 - struct reftable_reader *r;
607 + struct reftable_table *t;
608 uint64_t file_size = block_source_size(source);
609 uint32_t read_size;
610 ssize_t bytes_read;
611 int err;
612
613 - REFTABLE_CALLOC_ARRAY(r, 1);
614 - if (!r) {
613 + REFTABLE_CALLOC_ARRAY(t, 1);
614 + if (!t) {
615 err = REFTABLE_OUT_OF_MEMORY_ERROR;
616 goto done;
617 }
@@ -636,72 +636,72 @@ int reftable_reader_new(struct reftable_reader **out,
636 err = REFTABLE_FORMAT_ERROR;
637 goto done;
638 }
639 - r->version = header.data[4];
640 - if (r->version != 1 && r->version != 2) {
639 + t->version = header.data[4];
640 + if (t->version != 1 && t->version != 2) {
641 err = REFTABLE_FORMAT_ERROR;
642 goto done;
643 }
644
645 - r->size = file_size - footer_size(r->version);
646 - r->source = *source;
647 - r->name = reftable_strdup(name);
648 - if (!r->name) {
645 + t->size = file_size - footer_size(t->version);
646 + t->source = *source;
647 + t->name = reftable_strdup(name);
648 + if (!t->name) {
649 err = REFTABLE_OUT_OF_MEMORY_ERROR;
650 goto done;
651 }
652 - r->hash_id = 0;
653 - r->refcount = 1;
652 + t->hash_id = 0;
653 + t->refcount = 1;
654
655 - bytes_read = block_source_read_block(source, &footer, r->size,
656 - footer_size(r->version));
657 - if (bytes_read < 0 || (size_t)bytes_read != footer_size(r->version)) {
655 + bytes_read = block_source_read_block(source, &footer, t->size,
656 + footer_size(t->version));
657 + if (bytes_read < 0 || (size_t)bytes_read != footer_size(t->version)) {
658 err = REFTABLE_IO_ERROR;
659 goto done;
660 }
661
662 - err = parse_footer(r, footer.data, header.data);
662 + err = parse_footer(t, footer.data, header.data);
663 if (err)
664 goto done;
665
666 - *out = r;
666 + *out = t;
667
668 done:
669 reftable_block_done(&footer);
670 reftable_block_done(&header);
671 if (err) {
672 - if (r)
673 - reftable_free(r->name);
674 - reftable_free(r);
672 + if (t)
673 + reftable_free(t->name);
674 + reftable_free(t);
675 block_source_close(source);
676 }
677 return err;
678 }
679
680 -void reftable_reader_incref(struct reftable_reader *r)
680 +void reftable_table_incref(struct reftable_table *t)
681 {
682 - r->refcount++;
682 + t->refcount++;
683 }
684
685 -void reftable_reader_decref(struct reftable_reader *r)
685 +void reftable_table_decref(struct reftable_table *t)
686 {
687 - if (!r)
687 + if (!t)
688 return;
689 - if (--r->refcount)
689 + if (--t->refcount)
690 return;
691 - block_source_close(&r->source);
692 - REFTABLE_FREE_AND_NULL(r->name);
693 - reftable_free(r);
691 + block_source_close(&t->source);
692 + REFTABLE_FREE_AND_NULL(t->name);
693 + reftable_free(t);
694 }
695
696 -static int reftable_reader_refs_for_indexed(struct reftable_reader *r,
697 - struct reftable_iterator *it,
698 - uint8_t *oid)
696 +static int reftable_table_refs_for_indexed(struct reftable_table *t,
697 + struct reftable_iterator *it,
698 + uint8_t *oid)
699 {
700 struct reftable_record want = {
701 .type = BLOCK_TYPE_OBJ,
702 .u.obj = {
703 .hash_prefix = oid,
704 - .hash_prefix_len = r->object_id_len,
704 + .hash_prefix_len = t->object_id_len,
705 },
706 };
707 struct reftable_iterator oit = { NULL };
@@ -713,7 +713,7 @@ static int reftable_reader_refs_for_indexed(struct reftable_reader *r,
713 struct indexed_table_ref_iter *itr = NULL;
714
715 /* Look through the reverse index. */
716 - err = reader_init_iter(r, &oit, BLOCK_TYPE_OBJ);
716 + err = table_init_iter(t, &oit, BLOCK_TYPE_OBJ);
717 if (err < 0)
718 goto done;
719
@@ -727,14 +727,14 @@ static int reftable_reader_refs_for_indexed(struct reftable_reader *r,
727 goto done;
728
729 if (err > 0 || memcmp(want.u.obj.hash_prefix, got.u.obj.hash_prefix,
730 - r->object_id_len)) {
730 + t->object_id_len)) {
731 /* didn't find it; return empty iterator */
732 iterator_set_empty(it);
733 err = 0;
734 goto done;
735 }
736
737 - err = indexed_table_ref_iter_new(&itr, r, oid, hash_size(r->hash_id),
737 + err = indexed_table_ref_iter_new(&itr, t, oid, hash_size(t->hash_id),
738 got.u.obj.offsets,
739 got.u.obj.offset_len);
740 if (err < 0)
@@ -748,14 +748,14 @@ done:
748 return err;
749 }
750
751 -static int reftable_reader_refs_for_unindexed(struct reftable_reader *r,
752 - struct reftable_iterator *it,
753 - uint8_t *oid)
751 +static int reftable_table_refs_for_unindexed(struct reftable_table *t,
752 + struct reftable_iterator *it,
753 + uint8_t *oid)
754 {
755 struct table_iter *ti;
756 struct filtering_ref_iterator *filter = NULL;
757 struct filtering_ref_iterator empty = FILTERING_REF_ITERATOR_INIT;
758 - uint32_t oid_len = hash_size(r->hash_id);
758 + uint32_t oid_len = hash_size(t->hash_id);
759 int err;
760
761 REFTABLE_ALLOC_ARRAY(ti, 1);
@@ -764,7 +764,7 @@ static int reftable_reader_refs_for_unindexed(struct reftable_reader *r,
764 goto out;
765 }
766
767 - table_iter_init(ti, r);
767 + table_iter_init(ti, t);
768 err = table_iter_seek_start(ti, BLOCK_TYPE_REF, 0);
769 if (err < 0)
770 goto out;
@@ -795,25 +795,25 @@ out:
795 return err;
796 }
797
798 -int reftable_reader_refs_for(struct reftable_reader *r,
799 - struct reftable_iterator *it, uint8_t *oid)
798 +int reftable_table_refs_for(struct reftable_table *t,
799 + struct reftable_iterator *it, uint8_t *oid)
800 {
801 - if (r->obj_offsets.is_present)
802 - return reftable_reader_refs_for_indexed(r, it, oid);
803 - return reftable_reader_refs_for_unindexed(r, it, oid);
801 + if (t->obj_offsets.is_present)
802 + return reftable_table_refs_for_indexed(t, it, oid);
803 + return reftable_table_refs_for_unindexed(t, it, oid);
804 }
805
806 -uint64_t reftable_reader_max_update_index(struct reftable_reader *r)
806 +uint64_t reftable_table_max_update_index(struct reftable_table *t)
807 {
808 - return r->max_update_index;
808 + return t->max_update_index;
809 }
810
811 -uint64_t reftable_reader_min_update_index(struct reftable_reader *r)
811 +uint64_t reftable_table_min_update_index(struct reftable_table *t)
812 {
813 - return r->min_update_index;
813 + return t->min_update_index;
814 }
815
816 -int reftable_reader_print_blocks(const char *tablename)
816 +int reftable_table_print_blocks(const char *tablename)
817 {
818 struct {
819 const char *name;
@@ -833,7 +833,7 @@ int reftable_reader_print_blocks(const char *tablename)
833 },
834 };
835 struct reftable_block_source src = { 0 };
836 - struct reftable_reader *r = NULL;
836 + struct reftable_table *table = NULL;
837 struct table_iter ti = { 0 };
838 size_t i;
839 int err;
@@ -842,14 +842,14 @@ int reftable_reader_print_blocks(const char *tablename)
842 if (err < 0)
843 goto done;
844
845 - err = reftable_reader_new(&r, &src, tablename);
845 + err = reftable_table_new(&table, &src, tablename);
846 if (err < 0)
847 goto done;
848
849 - table_iter_init(&ti, r);
849 + table_iter_init(&ti, table);
850
851 printf("header:\n");
852 - printf(" block_size: %d\n", r->block_size);
852 + printf(" block_size: %d\n", table->block_size);
853
854 for (i = 0; i < sizeof(sections) / sizeof(*sections); i++) {
855 err = table_iter_seek_start(&ti, sections[i].type, 0);
@@ -873,7 +873,7 @@ int reftable_reader_print_blocks(const char *tablename)
873 }
874
875 done:
876 - reftable_reader_decref(r);
876 + reftable_table_decref(table);
877 table_iter_close(&ti);
878 return err;
879 }
reftable/table.h renamed
+15 -15
@@ -6,13 +6,13 @@
6 * https://developers.google.com/open-source/licenses/bsd
7 */
8
9 -#ifndef READER_H
10 -#define READER_H
9 +#ifndef TABLE_H
10 +#define TABLE_H
11
12 #include "block.h"
13 #include "record.h"
14 #include "reftable-iterator.h"
15 -#include "reftable-reader.h"
15 +#include "reftable-table.h"
16
17 uint64_t block_source_size(struct reftable_block_source *source);
18
@@ -22,14 +22,14 @@ ssize_t block_source_read_block(struct reftable_block_source *source,
22 void block_source_close(struct reftable_block_source *source);
23
24 /* metadata for a block type */
25 -struct reftable_reader_offsets {
25 +struct reftable_table_offsets {
26 int is_present;
27 uint64_t offset;
28 uint64_t index_offset;
29 };
30
31 /* The state for reading a reftable file. */
32 -struct reftable_reader {
32 +struct reftable_table {
33 /* for convenience, associate a name with the instance. */
34 char *name;
35 struct reftable_block_source source;
@@ -47,21 +47,21 @@ struct reftable_reader {
47 int object_id_len;
48 int version;
49
50 - struct reftable_reader_offsets ref_offsets;
51 - struct reftable_reader_offsets obj_offsets;
52 - struct reftable_reader_offsets log_offsets;
50 + struct reftable_table_offsets ref_offsets;
51 + struct reftable_table_offsets obj_offsets;
52 + struct reftable_table_offsets log_offsets;
53
54 uint64_t refcount;
55 };
56
57 -const char *reader_name(struct reftable_reader *r);
57 +const char *reftable_table_name(struct reftable_table *t);
58
59 -int reader_init_iter(struct reftable_reader *r,
60 - struct reftable_iterator *it,
61 - uint8_t typ);
59 +int table_init_iter(struct reftable_table *t,
60 + struct reftable_iterator *it,
61 + uint8_t typ);
62
63 -/* initialize a block reader to read from `r` */
64 -int reader_init_block_reader(struct reftable_reader *r, struct block_reader *br,
65 - uint64_t next_off, uint8_t want_typ);
63 +/* initialize a block reader to read from `t` */
64 +int table_init_block_reader(struct reftable_table *t, struct block_reader *br,
65 + uint64_t next_off, uint8_t want_typ);
66
67 #endif
t/helper/test-reftable.c
+7 -7
@@ -4,8 +4,8 @@
4 #include "reftable/system.h"
5 #include "reftable/reftable-error.h"
6 #include "reftable/reftable-merged.h"
7 -#include "reftable/reftable-reader.h"
7 #include "reftable/reftable-stack.h"
8 +#include "reftable/reftable-table.h"
9 #include "test-tool.h"
10
11 static void print_help(void)
@@ -126,19 +126,19 @@ static int dump_reftable(const char *tablename)
126 {
127 struct reftable_block_source src = { 0 };
128 struct reftable_merged_table *mt = NULL;
129 - struct reftable_reader *r = NULL;
129 + struct reftable_table *table = NULL;
130 int err;
131
132 err = reftable_block_source_from_file(&src, tablename);
133 if (err < 0)
134 goto done;
135
136 - err = reftable_reader_new(&r, &src, tablename);
136 + err = reftable_table_new(&table, &src, tablename);
137 if (err < 0)
138 goto done;
139
140 - err = reftable_merged_table_new(&mt, &r, 1,
141 - reftable_reader_hash_id(r));
140 + err = reftable_merged_table_new(&mt, &table, 1,
141 + reftable_table_hash_id(table));
142 if (err < 0)
143 goto done;
144
@@ -146,7 +146,7 @@ static int dump_reftable(const char *tablename)
146
147 done:
148 reftable_merged_table_free(mt);
149 - reftable_reader_decref(r);
149 + reftable_table_decref(table);
150 return err;
151 }
152
@@ -184,7 +184,7 @@ int cmd__dump_reftable(int argc, const char **argv)
184 arg = argv[1];
185
186 if (opt_dump_blocks) {
187 - err = reftable_reader_print_blocks(arg);
187 + err = reftable_table_print_blocks(arg);
188 } else if (opt_dump_table) {
189 err = dump_reftable(arg);
190 } else if (opt_dump_stack) {
t/meson.build
+1 -1
@@ -56,10 +56,10 @@ unit_test_programs = [
56 'unit-tests/t-reftable-block.c',
57 'unit-tests/t-reftable-merged.c',
58 'unit-tests/t-reftable-pq.c',
59 - 'unit-tests/t-reftable-reader.c',
59 'unit-tests/t-reftable-readwrite.c',
60 'unit-tests/t-reftable-record.c',
61 'unit-tests/t-reftable-stack.c',
62 + 'unit-tests/t-reftable-table.c',
63 'unit-tests/t-trailer.c',
64 'unit-tests/t-urlmatch-normalization.c',
65 ]
t/unit-tests/t-reftable-merged.c
+37 -37
@@ -11,7 +11,7 @@ https://developers.google.com/open-source/licenses/bsd
11 #include "reftable/blocksource.h"
12 #include "reftable/constants.h"
13 #include "reftable/merged.h"
14 -#include "reftable/reader.h"
14 +#include "reftable/table.h"
15 #include "reftable/reftable-error.h"
16 #include "reftable/reftable-merged.h"
17 #include "reftable/reftable-writer.h"
@@ -19,7 +19,7 @@ https://developers.google.com/open-source/licenses/bsd
19 static struct reftable_merged_table *
20 merged_table_from_records(struct reftable_ref_record **refs,
21 struct reftable_block_source **source,
22 - struct reftable_reader ***readers, const size_t *sizes,
22 + struct reftable_table ***tables, const size_t *sizes,
23 struct reftable_buf *buf, const size_t n)
24 {
25 struct reftable_merged_table *mt = NULL;
@@ -28,8 +28,8 @@ merged_table_from_records(struct reftable_ref_record **refs,
28 };
29 int err;
30
31 - REFTABLE_CALLOC_ARRAY(*readers, n);
32 - check(*readers != NULL);
31 + REFTABLE_CALLOC_ARRAY(*tables, n);
32 + check(*tables != NULL);
33 REFTABLE_CALLOC_ARRAY(*source, n);
34 check(*source != NULL);
35
@@ -37,21 +37,21 @@ merged_table_from_records(struct reftable_ref_record **refs,
37 t_reftable_write_to_buf(&buf[i], refs[i], sizes[i], NULL, 0, &opts);
38 block_source_from_buf(&(*source)[i], &buf[i]);
39
40 - err = reftable_reader_new(&(*readers)[i], &(*source)[i],
41 - "name");
40 + err = reftable_table_new(&(*tables)[i], &(*source)[i],
41 + "name");
42 check(!err);
43 }
44
45 - err = reftable_merged_table_new(&mt, *readers, n, REFTABLE_HASH_SHA1);
45 + err = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1);
46 check(!err);
47 return mt;
48 }
49
50 -static void readers_destroy(struct reftable_reader **readers, const size_t n)
50 +static void tables_destroy(struct reftable_table **tables, const size_t n)
51 {
52 for (size_t i = 0; i < n; i++)
53 - reftable_reader_decref(readers[i]);
54 - reftable_free(readers);
53 + reftable_table_decref(tables[i]);
54 + reftable_free(tables);
55 }
56
57 static void t_merged_single_record(void)
@@ -77,9 +77,9 @@ static void t_merged_single_record(void)
77 size_t sizes[] = { ARRAY_SIZE(r1), ARRAY_SIZE(r2), ARRAY_SIZE(r3) };
78 struct reftable_buf bufs[3] = { REFTABLE_BUF_INIT, REFTABLE_BUF_INIT, REFTABLE_BUF_INIT };
79 struct reftable_block_source *bs = NULL;
80 - struct reftable_reader **readers = NULL;
80 + struct reftable_table **tables = NULL;
81 struct reftable_merged_table *mt =
82 - merged_table_from_records(refs, &bs, &readers, sizes, bufs, 3);
82 + merged_table_from_records(refs, &bs, &tables, sizes, bufs, 3);
83 struct reftable_ref_record ref = { 0 };
84 struct reftable_iterator it = { 0 };
85 int err;
@@ -94,7 +94,7 @@ static void t_merged_single_record(void)
94 check(reftable_ref_record_equal(&r2[0], &ref, REFTABLE_HASH_SIZE_SHA1));
95 reftable_ref_record_release(&ref);
96 reftable_iterator_destroy(&it);
97 - readers_destroy(readers, 3);
97 + tables_destroy(tables, 3);
98 reftable_merged_table_free(mt);
99 for (size_t i = 0; i < ARRAY_SIZE(bufs); i++)
100 reftable_buf_release(&bufs[i]);
@@ -154,9 +154,9 @@ static void t_merged_refs(void)
154 size_t sizes[3] = { ARRAY_SIZE(r1), ARRAY_SIZE(r2), ARRAY_SIZE(r3) };
155 struct reftable_buf bufs[3] = { REFTABLE_BUF_INIT, REFTABLE_BUF_INIT, REFTABLE_BUF_INIT };
156 struct reftable_block_source *bs = NULL;
157 - struct reftable_reader **readers = NULL;
157 + struct reftable_table **tables = NULL;
158 struct reftable_merged_table *mt =
159 - merged_table_from_records(refs, &bs, &readers, sizes, bufs, 3);
159 + merged_table_from_records(refs, &bs, &tables, sizes, bufs, 3);
160 struct reftable_iterator it = { 0 };
161 int err;
162 struct reftable_ref_record *out = NULL;
@@ -193,7 +193,7 @@ static void t_merged_refs(void)
193
194 for (i = 0; i < 3; i++)
195 reftable_buf_release(&bufs[i]);
196 - readers_destroy(readers, 3);
196 + tables_destroy(tables, 3);
197 reftable_merged_table_free(mt);
198 reftable_free(bs);
199 }
@@ -238,12 +238,12 @@ static void t_merged_seek_multiple_times(void)
238 REFTABLE_BUF_INIT, REFTABLE_BUF_INIT,
239 };
240 struct reftable_block_source *sources = NULL;
241 - struct reftable_reader **readers = NULL;
241 + struct reftable_table **tables = NULL;
242 struct reftable_ref_record rec = { 0 };
243 struct reftable_iterator it = { 0 };
244 struct reftable_merged_table *mt;
245
246 - mt = merged_table_from_records(refs, &sources, &readers, sizes, bufs, 2);
246 + mt = merged_table_from_records(refs, &sources, &tables, sizes, bufs, 2);
247 merged_table_init_iter(mt, &it, BLOCK_TYPE_REF);
248
249 for (size_t i = 0; i < 5; i++) {
@@ -266,7 +266,7 @@ static void t_merged_seek_multiple_times(void)
266
267 for (size_t i = 0; i < ARRAY_SIZE(bufs); i++)
268 reftable_buf_release(&bufs[i]);
269 - readers_destroy(readers, ARRAY_SIZE(refs));
269 + tables_destroy(tables, ARRAY_SIZE(refs));
270 reftable_ref_record_release(&rec);
271 reftable_iterator_destroy(&it);
272 reftable_merged_table_free(mt);
@@ -313,13 +313,13 @@ static void t_merged_seek_multiple_times_without_draining(void)
313 REFTABLE_BUF_INIT, REFTABLE_BUF_INIT,
314 };
315 struct reftable_block_source *sources = NULL;
316 - struct reftable_reader **readers = NULL;
316 + struct reftable_table **tables = NULL;
317 struct reftable_ref_record rec = { 0 };
318 struct reftable_iterator it = { 0 };
319 struct reftable_merged_table *mt;
320 int err;
321
322 - mt = merged_table_from_records(refs, &sources, &readers, sizes, bufs, 2);
322 + mt = merged_table_from_records(refs, &sources, &tables, sizes, bufs, 2);
323 merged_table_init_iter(mt, &it, BLOCK_TYPE_REF);
324
325 err = reftable_iterator_seek_ref(&it, "b");
@@ -338,7 +338,7 @@ static void t_merged_seek_multiple_times_without_draining(void)
338
339 for (size_t i = 0; i < ARRAY_SIZE(bufs); i++)
340 reftable_buf_release(&bufs[i]);
341 - readers_destroy(readers, ARRAY_SIZE(refs));
341 + tables_destroy(tables, ARRAY_SIZE(refs));
342 reftable_ref_record_release(&rec);
343 reftable_iterator_destroy(&it);
344 reftable_merged_table_free(mt);
@@ -348,7 +348,7 @@ static void t_merged_seek_multiple_times_without_draining(void)
348 static struct reftable_merged_table *
349 merged_table_from_log_records(struct reftable_log_record **logs,
350 struct reftable_block_source **source,
351 - struct reftable_reader ***readers, const size_t *sizes,
351 + struct reftable_table ***tables, const size_t *sizes,
352 struct reftable_buf *buf, const size_t n)
353 {
354 struct reftable_merged_table *mt = NULL;
@@ -358,8 +358,8 @@ merged_table_from_log_records(struct reftable_log_record **logs,
358 };
359 int err;
360
361 - REFTABLE_CALLOC_ARRAY(*readers, n);
362 - check(*readers != NULL);
361 + REFTABLE_CALLOC_ARRAY(*tables, n);
362 + check(*tables != NULL);
363 REFTABLE_CALLOC_ARRAY(*source, n);
364 check(*source != NULL);
365
@@ -367,12 +367,12 @@ merged_table_from_log_records(struct reftable_log_record **logs,
367 t_reftable_write_to_buf(&buf[i], NULL, 0, logs[i], sizes[i], &opts);
368 block_source_from_buf(&(*source)[i], &buf[i]);
369
370 - err = reftable_reader_new(&(*readers)[i], &(*source)[i],
371 - "name");
370 + err = reftable_table_new(&(*tables)[i], &(*source)[i],
371 + "name");
372 check(!err);
373 }
374
375 - err = reftable_merged_table_new(&mt, *readers, n, REFTABLE_HASH_SHA1);
375 + err = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1);
376 check(!err);
377 return mt;
378 }
@@ -435,9 +435,9 @@ static void t_merged_logs(void)
435 size_t sizes[3] = { ARRAY_SIZE(r1), ARRAY_SIZE(r2), ARRAY_SIZE(r3) };
436 struct reftable_buf bufs[3] = { REFTABLE_BUF_INIT, REFTABLE_BUF_INIT, REFTABLE_BUF_INIT };
437 struct reftable_block_source *bs = NULL;
438 - struct reftable_reader **readers = NULL;
438 + struct reftable_table **tables = NULL;
439 struct reftable_merged_table *mt = merged_table_from_log_records(
440 - logs, &bs, &readers, sizes, bufs, 3);
440 + logs, &bs, &tables, sizes, bufs, 3);
441 struct reftable_iterator it = { 0 };
442 int err;
443 struct reftable_log_record *out = NULL;
@@ -485,7 +485,7 @@ static void t_merged_logs(void)
485
486 for (i = 0; i < 3; i++)
487 reftable_buf_release(&bufs[i]);
488 - readers_destroy(readers, 3);
488 + tables_destroy(tables, 3);
489 reftable_merged_table_free(mt);
490 reftable_free(bs);
491 }
@@ -502,7 +502,7 @@ static void t_default_write_opts(void)
502 int err;
503 struct reftable_block_source source = { 0 };
504 uint32_t hash_id;
505 - struct reftable_reader *rd = NULL;
505 + struct reftable_table *table = NULL;
506 struct reftable_merged_table *merged = NULL;
507
508 reftable_writer_set_limits(w, 1, 1);
@@ -516,18 +516,18 @@ static void t_default_write_opts(void)
516
517 block_source_from_buf(&source, &buf);
518
519 - err = reftable_reader_new(&rd, &source, "filename");
519 + err = reftable_table_new(&table, &source, "filename");
520 check(!err);
521
522 - hash_id = reftable_reader_hash_id(rd);
522 + hash_id = reftable_table_hash_id(table);
523 check_int(hash_id, ==, REFTABLE_HASH_SHA1);
524
525 - err = reftable_merged_table_new(&merged, &rd, 1, REFTABLE_HASH_SHA256);
525 + err = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA256);
526 check_int(err, ==, REFTABLE_FORMAT_ERROR);
527 - err = reftable_merged_table_new(&merged, &rd, 1, REFTABLE_HASH_SHA1);
527 + err = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA1);
528 check(!err);
529
530 - reftable_reader_decref(rd);
530 + reftable_table_decref(table);
531 reftable_merged_table_free(merged);
532 reftable_buf_release(&buf);
533 }
t/unit-tests/t-reftable-readwrite.c
+48 -48
@@ -12,9 +12,9 @@ https://developers.google.com/open-source/licenses/bsd
12 #include "lib-reftable.h"
13 #include "reftable/basics.h"
14 #include "reftable/blocksource.h"
15 -#include "reftable/reader.h"
15 #include "reftable/reftable-error.h"
16 #include "reftable/reftable-writer.h"
17 +#include "reftable/table.h"
18 #include "strbuf.h"
19
20 static const int update_index = 5;
@@ -204,7 +204,7 @@ static void t_log_write_read(void)
204 struct reftable_ref_record ref = { 0 };
205 struct reftable_log_record log = { 0 };
206 struct reftable_iterator it = { 0 };
207 - struct reftable_reader *reader;
207 + struct reftable_table *table;
208 struct reftable_block_source source = { 0 };
209 struct reftable_buf buf = REFTABLE_BUF_INIT;
210 struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
@@ -254,10 +254,10 @@ static void t_log_write_read(void)
254
255 block_source_from_buf(&source, &buf);
256
257 - err = reftable_reader_new(&reader, &source, "file.log");
257 + err = reftable_table_new(&table, &source, "file.log");
258 check(!err);
259
260 - err = reftable_reader_init_ref_iterator(reader, &it);
260 + err = reftable_table_init_ref_iterator(table, &it);
261 check(!err);
262
263 err = reftable_iterator_seek_ref(&it, names[N - 1]);
@@ -273,7 +273,7 @@ static void t_log_write_read(void)
273 reftable_iterator_destroy(&it);
274 reftable_ref_record_release(&ref);
275
276 - err = reftable_reader_init_log_iterator(reader, &it);
276 + err = reftable_table_init_log_iterator(table, &it);
277 check(!err);
278 err = reftable_iterator_seek_log(&it, "");
279 check(!err);
@@ -294,7 +294,7 @@ static void t_log_write_read(void)
294 /* cleanup. */
295 reftable_buf_release(&buf);
296 free_names(names);
297 - reftable_reader_decref(reader);
297 + reftable_table_decref(table);
298 }
299
300 static void t_log_zlib_corruption(void)
@@ -303,7 +303,7 @@ static void t_log_zlib_corruption(void)
303 .block_size = 256,
304 };
305 struct reftable_iterator it = { 0 };
306 - struct reftable_reader *reader;
306 + struct reftable_table *table;
307 struct reftable_block_source source = { 0 };
308 struct reftable_buf buf = REFTABLE_BUF_INIT;
309 struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
@@ -345,10 +345,10 @@ static void t_log_zlib_corruption(void)
345
346 block_source_from_buf(&source, &buf);
347
348 - err = reftable_reader_new(&reader, &source, "file.log");
348 + err = reftable_table_new(&table, &source, "file.log");
349 check(!err);
350
351 - err = reftable_reader_init_log_iterator(reader, &it);
351 + err = reftable_table_init_log_iterator(table, &it);
352 check(!err);
353 err = reftable_iterator_seek_log(&it, "refname");
354 check_int(err, ==, REFTABLE_ZLIB_ERROR);
@@ -356,7 +356,7 @@ static void t_log_zlib_corruption(void)
356 reftable_iterator_destroy(&it);
357
358 /* cleanup. */
359 - reftable_reader_decref(reader);
359 + reftable_table_decref(table);
360 reftable_buf_release(&buf);
361 }
362
@@ -367,7 +367,7 @@ static void t_table_read_write_sequential(void)
367 int N = 50;
368 struct reftable_iterator it = { 0 };
369 struct reftable_block_source source = { 0 };
370 - struct reftable_reader *reader;
370 + struct reftable_table *table;
371 int err = 0;
372 int j = 0;
373
@@ -375,10 +375,10 @@ static void t_table_read_write_sequential(void)
375
376 block_source_from_buf(&source, &buf);
377
378 - err = reftable_reader_new(&reader, &source, "file.ref");
378 + err = reftable_table_new(&table, &source, "file.ref");
379 check(!err);
380
381 - err = reftable_reader_init_ref_iterator(reader, &it);
381 + err = reftable_table_init_ref_iterator(table, &it);
382 check(!err);
383 err = reftable_iterator_seek_ref(&it, "");
384 check(!err);
@@ -396,7 +396,7 @@ static void t_table_read_write_sequential(void)
396 check_int(j, ==, N);
397
398 reftable_iterator_destroy(&it);
399 - reftable_reader_decref(reader);
399 + reftable_table_decref(table);
400 reftable_buf_release(&buf);
401 free_names(names);
402 }
@@ -417,7 +417,7 @@ static void t_table_read_api(void)
417 char **names;
418 struct reftable_buf buf = REFTABLE_BUF_INIT;
419 int N = 50;
420 - struct reftable_reader *reader;
420 + struct reftable_table *table;
421 struct reftable_block_source source = { 0 };
422 int err;
423 struct reftable_log_record log = { 0 };
@@ -427,10 +427,10 @@ static void t_table_read_api(void)
427
428 block_source_from_buf(&source, &buf);
429
430 - err = reftable_reader_new(&reader, &source, "file.ref");
430 + err = reftable_table_new(&table, &source, "file.ref");
431 check(!err);
432
433 - err = reftable_reader_init_ref_iterator(reader, &it);
433 + err = reftable_table_init_ref_iterator(table, &it);
434 check(!err);
435 err = reftable_iterator_seek_ref(&it, names[0]);
436 check(!err);
@@ -441,7 +441,7 @@ static void t_table_read_api(void)
441 reftable_buf_release(&buf);
442 free_names(names);
443 reftable_iterator_destroy(&it);
444 - reftable_reader_decref(reader);
444 + reftable_table_decref(table);
445 reftable_buf_release(&buf);
446 }
447
@@ -450,7 +450,7 @@ static void t_table_read_write_seek(int index, enum reftable_hash hash_id)
450 char **names;
451 struct reftable_buf buf = REFTABLE_BUF_INIT;
452 int N = 50;
453 - struct reftable_reader *reader;
453 + struct reftable_table *table;
454 struct reftable_block_source source = { 0 };
455 int err;
456 int i = 0;
@@ -463,18 +463,18 @@ static void t_table_read_write_seek(int index, enum reftable_hash hash_id)
463
464 block_source_from_buf(&source, &buf);
465
466 - err = reftable_reader_new(&reader, &source, "file.ref");
466 + err = reftable_table_new(&table, &source, "file.ref");
467 check(!err);
468 - check_int(hash_id, ==, reftable_reader_hash_id(reader));
468 + check_int(hash_id, ==, reftable_table_hash_id(table));
469
470 if (!index) {
471 - reader->ref_offsets.index_offset = 0;
471 + table->ref_offsets.index_offset = 0;
472 } else {
473 - check_int(reader->ref_offsets.index_offset, >, 0);
473 + check_int(table->ref_offsets.index_offset, >, 0);
474 }
475
476 for (i = 1; i < N; i++) {
477 - err = reftable_reader_init_ref_iterator(reader, &it);
477 + err = reftable_table_init_ref_iterator(table, &it);
478 check(!err);
479 err = reftable_iterator_seek_ref(&it, names[i]);
480 check(!err);
@@ -491,7 +491,7 @@ static void t_table_read_write_seek(int index, enum reftable_hash hash_id)
491 check(!reftable_buf_addstr(&pastLast, names[N - 1]));
492 check(!reftable_buf_addstr(&pastLast, "/"));
493
494 - err = reftable_reader_init_ref_iterator(reader, &it);
494 + err = reftable_table_init_ref_iterator(table, &it);
495 check(!err);
496 err = reftable_iterator_seek_ref(&it, pastLast.buf);
497 if (err == 0) {
@@ -507,7 +507,7 @@ static void t_table_read_write_seek(int index, enum reftable_hash hash_id)
507
508 reftable_buf_release(&buf);
509 free_names(names);
510 - reftable_reader_decref(reader);
510 + reftable_table_decref(table);
511 }
512
513 static void t_table_read_write_seek_linear(void)
@@ -535,7 +535,7 @@ static void t_table_refs_for(int indexed)
535 .block_size = 256,
536 };
537 struct reftable_ref_record ref = { 0 };
538 - struct reftable_reader *reader;
538 + struct reftable_table *table;
539 struct reftable_block_source source = { 0 };
540 struct reftable_buf buf = REFTABLE_BUF_INIT;
541 struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
@@ -585,18 +585,18 @@ static void t_table_refs_for(int indexed)
585
586 block_source_from_buf(&source, &buf);
587
588 - err = reftable_reader_new(&reader, &source, "file.ref");
588 + err = reftable_table_new(&table, &source, "file.ref");
589 check(!err);
590 if (!indexed)
591 - reader->obj_offsets.is_present = 0;
591 + table->obj_offsets.is_present = 0;
592
593 - err = reftable_reader_init_ref_iterator(reader, &it);
593 + err = reftable_table_init_ref_iterator(table, &it);
594 check(!err);
595 err = reftable_iterator_seek_ref(&it, "");
596 check(!err);
597 reftable_iterator_destroy(&it);
598
599 - err = reftable_reader_refs_for(reader, &it, want_hash);
599 + err = reftable_table_refs_for(table, &it, want_hash);
600 check(!err);
601
602 for (j = 0; ; j++) {
@@ -613,7 +613,7 @@ static void t_table_refs_for(int indexed)
613 reftable_buf_release(&buf);
614 free_names(want_names);
615 reftable_iterator_destroy(&it);
616 - reftable_reader_decref(reader);
616 + reftable_table_decref(table);
617 }
618
619 static void t_table_refs_for_no_index(void)
@@ -632,7 +632,7 @@ static void t_write_empty_table(void)
632 struct reftable_buf buf = REFTABLE_BUF_INIT;
633 struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
634 struct reftable_block_source source = { 0 };
635 - struct reftable_reader *rd = NULL;
635 + struct reftable_table *table = NULL;
636 struct reftable_ref_record rec = { 0 };
637 struct reftable_iterator it = { 0 };
638 int err;
@@ -647,10 +647,10 @@ static void t_write_empty_table(void)
647
648 block_source_from_buf(&source, &buf);
649
650 - err = reftable_reader_new(&rd, &source, "filename");
650 + err = reftable_table_new(&table, &source, "filename");
651 check(!err);
652
653 - err = reftable_reader_init_ref_iterator(rd, &it);
653 + err = reftable_table_init_ref_iterator(table, &it);
654 check(!err);
655 err = reftable_iterator_seek_ref(&it, "");
656 check(!err);
@@ -659,7 +659,7 @@ static void t_write_empty_table(void)
659 check_int(err, >, 0);
660
661 reftable_iterator_destroy(&it);
662 - reftable_reader_decref(rd);
662 + reftable_table_decref(table);
663 reftable_buf_release(&buf);
664 }
665
@@ -803,7 +803,7 @@ static void t_write_multiple_indices(void)
803 struct reftable_iterator it = { 0 };
804 const struct reftable_stats *stats;
805 struct reftable_writer *writer;
806 - struct reftable_reader *reader;
806 + struct reftable_table *table;
807 char buf[128];
808 int err, i;
809
@@ -852,21 +852,21 @@ static void t_write_multiple_indices(void)
852 check_int(stats->log_stats.index_offset, >, 0);
853
854 block_source_from_buf(&source, &writer_buf);
855 - err = reftable_reader_new(&reader, &source, "filename");
855 + err = reftable_table_new(&table, &source, "filename");
856 check(!err);
857
858 /*
859 * Seeking the log uses the log index now. In case there is any
860 * confusion regarding indices we would notice here.
861 */
862 - err = reftable_reader_init_log_iterator(reader, &it);
862 + err = reftable_table_init_log_iterator(table, &it);
863 check(!err);
864 err = reftable_iterator_seek_log(&it, "");
865 check(!err);
866
867 reftable_iterator_destroy(&it);
868 reftable_writer_free(writer);
869 - reftable_reader_decref(reader);
869 + reftable_table_decref(table);
870 reftable_buf_release(&writer_buf);
871 }
872
@@ -880,7 +880,7 @@ static void t_write_multi_level_index(void)
880 struct reftable_iterator it = { 0 };
881 const struct reftable_stats *stats;
882 struct reftable_writer *writer;
883 - struct reftable_reader *reader;
883 + struct reftable_table *table;
884 int err;
885
886 writer = t_reftable_strbuf_writer(&writer_buf, &opts);
@@ -909,20 +909,20 @@ static void t_write_multi_level_index(void)
909 check_int(stats->ref_stats.max_index_level, ==, 2);
910
911 block_source_from_buf(&source, &writer_buf);
912 - err = reftable_reader_new(&reader, &source, "filename");
912 + err = reftable_table_new(&table, &source, "filename");
913 check(!err);
914
915 /*
916 * Seeking the last ref should work as expected.
917 */
918 - err = reftable_reader_init_ref_iterator(reader, &it);
918 + err = reftable_table_init_ref_iterator(table, &it);
919 check(!err);
920 err = reftable_iterator_seek_ref(&it, "refs/heads/199");
921 check(!err);
922
923 reftable_iterator_destroy(&it);
924 reftable_writer_free(writer);
925 - reftable_reader_decref(reader);
925 + reftable_table_decref(table);
926 reftable_buf_release(&writer_buf);
927 reftable_buf_release(&buf);
928 }
@@ -931,11 +931,11 @@ static void t_corrupt_table_empty(void)
931 {
932 struct reftable_buf buf = REFTABLE_BUF_INIT;
933 struct reftable_block_source source = { 0 };
934 - struct reftable_reader *reader;
934 + struct reftable_table *table;
935 int err;
936
937 block_source_from_buf(&source, &buf);
938 - err = reftable_reader_new(&reader, &source, "file.log");
938 + err = reftable_table_new(&table, &source, "file.log");
939 check_int(err, ==, REFTABLE_FORMAT_ERROR);
940 }
941
@@ -944,12 +944,12 @@ static void t_corrupt_table(void)
944 uint8_t zeros[1024] = { 0 };
945 struct reftable_buf buf = REFTABLE_BUF_INIT;
946 struct reftable_block_source source = { 0 };
947 - struct reftable_reader *reader;
947 + struct reftable_table *table;
948 int err;
949 check(!reftable_buf_add(&buf, zeros, sizeof(zeros)));
950
951 block_source_from_buf(&source, &buf);
952 - err = reftable_reader_new(&reader, &source, "file.log");
952 + err = reftable_table_new(&table, &source, "file.log");
953 check_int(err, ==, REFTABLE_FORMAT_ERROR);
954
955 reftable_buf_release(&buf);
t/unit-tests/t-reftable-stack.c
+33 -33
@@ -12,9 +12,9 @@ https://developers.google.com/open-source/licenses/bsd
12 #include "lib-reftable.h"
13 #include "dir.h"
14 #include "reftable/merged.h"
15 -#include "reftable/reader.h"
15 #include "reftable/reftable-error.h"
16 #include "reftable/stack.h"
17 +#include "reftable/table.h"
18 #include "strbuf.h"
19 #include "tempfile.h"
20 #include <dirent.h>
@@ -176,7 +176,7 @@ static void t_reftable_stack_add_one(void)
176 err = reftable_stack_read_ref(st, ref.refname, &dest);
177 check(!err);
178 check(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));
179 - check_int(st->readers_len, >, 0);
179 + check_int(st->tables_len, >, 0);
180
181 #ifndef GIT_WINDOWS_NATIVE
182 check(!reftable_buf_addstr(&scratch, dir));
@@ -189,7 +189,7 @@ static void t_reftable_stack_add_one(void)
189 check(!reftable_buf_addstr(&scratch, dir));
190 check(!reftable_buf_addstr(&scratch, "/"));
191 /* do not try at home; not an external API for reftable. */
192 - check(!reftable_buf_addstr(&scratch, st->readers[0]->name));
192 + check(!reftable_buf_addstr(&scratch, st->tables[0]->name));
193 err = stat(scratch.buf, &stat_result);
194 check(!err);
195 check_int((stat_result.st_mode & 0777), ==, opts.default_permissions);
@@ -402,9 +402,9 @@ static void t_reftable_stack_transaction_api_performs_auto_compaction(void)
402 * all tables in the stack.
403 */
404 if (i != n)
405 - check_int(st->merged->readers_len, ==, i + 1);
405 + check_int(st->merged->tables_len, ==, i + 1);
406 else
407 - check_int(st->merged->readers_len, ==, 1);
407 + check_int(st->merged->tables_len, ==, 1);
408 }
409
410 reftable_stack_destroy(st);
@@ -430,7 +430,7 @@ static void t_reftable_stack_auto_compaction_fails_gracefully(void)
430
431 err = reftable_stack_add(st, write_test_ref, &ref);
432 check(!err);
433 - check_int(st->merged->readers_len, ==, 1);
433 + check_int(st->merged->tables_len, ==, 1);
434 check_int(st->stats.attempts, ==, 0);
435 check_int(st->stats.failures, ==, 0);
436
@@ -441,14 +441,14 @@ static void t_reftable_stack_auto_compaction_fails_gracefully(void)
441 */
442 check(!reftable_buf_addstr(&table_path, dir));
443 check(!reftable_buf_addstr(&table_path, "/"));
444 - check(!reftable_buf_addstr(&table_path, st->readers[0]->name));
444 + check(!reftable_buf_addstr(&table_path, st->tables[0]->name));
445 check(!reftable_buf_addstr(&table_path, ".lock"));
446 write_file_buf(table_path.buf, "", 0);
447
448 ref.update_index = 2;
449 err = reftable_stack_add(st, write_test_ref, &ref);
450 check(!err);
451 - check_int(st->merged->readers_len, ==, 2);
451 + check_int(st->merged->tables_len, ==, 2);
452 check_int(st->stats.attempts, ==, 1);
453 check_int(st->stats.failures, ==, 1);
454
@@ -592,7 +592,7 @@ static void t_reftable_stack_add(void)
592 check(!reftable_buf_addstr(&path, dir));
593 check(!reftable_buf_addstr(&path, "/"));
594 /* do not try at home; not an external API for reftable. */
595 - check(!reftable_buf_addstr(&path, st->readers[0]->name));
595 + check(!reftable_buf_addstr(&path, st->tables[0]->name));
596 err = stat(path.buf, &stat_result);
597 check(!err);
598 check_int((stat_result.st_mode & 0777), ==, opts.default_permissions);
@@ -1026,7 +1026,7 @@ static void t_reftable_stack_auto_compaction(void)
1026
1027 err = reftable_stack_auto_compact(st);
1028 check(!err);
1029 - check(i < 2 || st->merged->readers_len < 2 * fastlogN(i, 2));
1029 + check(i < 2 || st->merged->tables_len < 2 * fastlogN(i, 2));
1030 }
1031
1032 check_int(reftable_stack_compaction_stats(st)->entries_written, <,
@@ -1061,7 +1061,7 @@ static void t_reftable_stack_auto_compaction_factor(void)
1061 err = reftable_stack_add(st, &write_test_ref, &ref);
1062 check(!err);
1063
1064 - check(i < 5 || st->merged->readers_len < 5 * fastlogN(i, 5));
1064 + check(i < 5 || st->merged->tables_len < 5 * fastlogN(i, 5));
1065 }
1066
1067 reftable_stack_destroy(st);
@@ -1082,7 +1082,7 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)
1082 check(!err);
1083
1084 write_n_ref_tables(st, 5);
1085 - check_int(st->merged->readers_len, ==, 5);
1085 + check_int(st->merged->tables_len, ==, 5);
1086
1087 /*
1088 * Given that all tables we have written should be roughly the same
@@ -1091,7 +1091,7 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)
1091 */
1092 check(!reftable_buf_addstr(&buf, dir));
1093 check(!reftable_buf_addstr(&buf, "/"));
1094 - check(!reftable_buf_addstr(&buf, st->readers[2]->name));
1094 + check(!reftable_buf_addstr(&buf, st->tables[2]->name));
1095 check(!reftable_buf_addstr(&buf, ".lock"));
1096 write_file_buf(buf.buf, "", 0);
1097
@@ -1104,7 +1104,7 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)
1104 err = reftable_stack_auto_compact(st);
1105 check(!err);
1106 check_int(st->stats.failures, ==, 0);
1107 - check_int(st->merged->readers_len, ==, 4);
1107 + check_int(st->merged->tables_len, ==, 4);
1108
1109 reftable_stack_destroy(st);
1110 reftable_buf_release(&buf);
@@ -1149,9 +1149,9 @@ static void t_reftable_stack_add_performs_auto_compaction(void)
1149 * all tables in the stack.
1150 */
1151 if (i != n)
1152 - check_int(st->merged->readers_len, ==, i + 1);
1152 + check_int(st->merged->tables_len, ==, i + 1);
1153 else
1154 - check_int(st->merged->readers_len, ==, 1);
1154 + check_int(st->merged->tables_len, ==, 1);
1155 }
1156
1157 reftable_stack_destroy(st);
@@ -1172,12 +1172,12 @@ static void t_reftable_stack_compaction_with_locked_tables(void)
1172 check(!err);
1173
1174 write_n_ref_tables(st, 3);
1175 - check_int(st->merged->readers_len, ==, 3);
1175 + check_int(st->merged->tables_len, ==, 3);
1176
1177 /* Lock one of the tables that we're about to compact. */
1178 check(!reftable_buf_addstr(&buf, dir));
1179 check(!reftable_buf_addstr(&buf, "/"));
1180 - check(!reftable_buf_addstr(&buf, st->readers[1]->name));
1180 + check(!reftable_buf_addstr(&buf, st->tables[1]->name));
1181 check(!reftable_buf_addstr(&buf, ".lock"));
1182 write_file_buf(buf.buf, "", 0);
1183
@@ -1188,7 +1188,7 @@ static void t_reftable_stack_compaction_with_locked_tables(void)
1188 err = reftable_stack_compact_all(st, NULL);
1189 check_int(err, ==, REFTABLE_LOCK_ERROR);
1190 check_int(st->stats.failures, ==, 1);
1191 - check_int(st->merged->readers_len, ==, 3);
1191 + check_int(st->merged->tables_len, ==, 3);
1192
1193 reftable_stack_destroy(st);
1194 reftable_buf_release(&buf);
@@ -1222,10 +1222,10 @@ static void t_reftable_stack_compaction_concurrent(void)
1222 static void unclean_stack_close(struct reftable_stack *st)
1223 {
1224 /* break abstraction boundary to simulate unclean shutdown. */
1225 - for (size_t i = 0; i < st->readers_len; i++)
1226 - reftable_reader_decref(st->readers[i]);
1227 - st->readers_len = 0;
1228 - REFTABLE_FREE_AND_NULL(st->readers);
1225 + for (size_t i = 0; i < st->tables_len; i++)
1226 + reftable_table_decref(st->tables[i]);
1227 + st->tables_len = 0;
1228 + REFTABLE_FREE_AND_NULL(st->tables);
1229 }
1230
1231 static void t_reftable_stack_compaction_concurrent_clean(void)
@@ -1275,7 +1275,7 @@ static void t_reftable_stack_read_across_reload(void)
1275 err = reftable_new_stack(&st1, dir, &opts);
1276 check(!err);
1277 write_n_ref_tables(st1, 2);
1278 - check_int(st1->merged->readers_len, ==, 2);
1278 + check_int(st1->merged->tables_len, ==, 2);
1279 reftable_stack_init_ref_iterator(st1, &it);
1280 err = reftable_iterator_seek_ref(&it, "");
1281 check(!err);
@@ -1283,10 +1283,10 @@ static void t_reftable_stack_read_across_reload(void)
1283 /* Set up a second stack for the same directory and compact it. */
1284 err = reftable_new_stack(&st2, dir, &opts);
1285 check(!err);
1286 - check_int(st2->merged->readers_len, ==, 2);
1286 + check_int(st2->merged->tables_len, ==, 2);
1287 err = reftable_stack_compact_all(st2, NULL);
1288 check(!err);
1289 - check_int(st2->merged->readers_len, ==, 1);
1289 + check_int(st2->merged->tables_len, ==, 1);
1290
1291 /*
1292 * Verify that we can continue to use the old iterator even after we
@@ -1294,7 +1294,7 @@ static void t_reftable_stack_read_across_reload(void)
1294 */
1295 err = reftable_stack_reload(st1);
1296 check(!err);
1297 - check_int(st1->merged->readers_len, ==, 1);
1297 + check_int(st1->merged->tables_len, ==, 1);
1298 err = reftable_iterator_next_ref(&it, &rec);
1299 check(!err);
1300 check_str(rec.refname, "refs/heads/branch-0000");
@@ -1325,19 +1325,19 @@ static void t_reftable_stack_reload_with_missing_table(void)
1325 err = reftable_new_stack(&st, dir, &opts);
1326 check(!err);
1327 write_n_ref_tables(st, 2);
1328 - check_int(st->merged->readers_len, ==, 2);
1328 + check_int(st->merged->tables_len, ==, 2);
1329 reftable_stack_init_ref_iterator(st, &it);
1330 err = reftable_iterator_seek_ref(&it, "");
1331 check(!err);
1332
1333 /*
1334 * Update the tables.list file with some garbage data, while reusing
1335 - * our old readers. This should trigger a partial reload of the stack,
1336 - * where we try to reuse our old readers.
1335 + * our old tables. This should trigger a partial reload of the stack,
1336 + * where we try to reuse our old tables.
1337 */
1338 - check(!reftable_buf_addstr(&content, st->readers[0]->name));
1338 + check(!reftable_buf_addstr(&content, st->tables[0]->name));
1339 check(!reftable_buf_addstr(&content, "\n"));
1340 - check(!reftable_buf_addstr(&content, st->readers[1]->name));
1340 + check(!reftable_buf_addstr(&content, st->tables[1]->name));
1341 check(!reftable_buf_addstr(&content, "\n"));
1342 check(!reftable_buf_addstr(&content, "garbage\n"));
1343 check(!reftable_buf_addstr(&table_path, st->list_file));
@@ -1348,7 +1348,7 @@ static void t_reftable_stack_reload_with_missing_table(void)
1348
1349 err = reftable_stack_reload(st);
1350 check_int(err, ==, -4);
1351 - check_int(st->merged->readers_len, ==, 2);
1351 + check_int(st->merged->tables_len, ==, 2);
1352
1353 /*
1354 * Even though the reload has failed, we should be able to continue
t/unit-tests/t-reftable-table.c renamed
+13 -13
@@ -1,9 +1,9 @@
1 #include "test-lib.h"
2 #include "lib-reftable.h"
3 #include "reftable/blocksource.h"
4 -#include "reftable/reader.h"
4 +#include "reftable/table.h"
5
6 -static int t_reader_seek_once(void)
6 +static int t_table_seek_once(void)
7 {
8 struct reftable_ref_record records[] = {
9 {
@@ -15,17 +15,17 @@ static int t_reader_seek_once(void)
15 struct reftable_block_source source = { 0 };
16 struct reftable_ref_record ref = { 0 };
17 struct reftable_iterator it = { 0 };
18 - struct reftable_reader *reader;
18 + struct reftable_table *table;
19 struct reftable_buf buf = REFTABLE_BUF_INIT;
20 int ret;
21
22 t_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);
23 block_source_from_buf(&source, &buf);
24
25 - ret = reftable_reader_new(&reader, &source, "name");
25 + ret = reftable_table_new(&table, &source, "name");
26 check(!ret);
27
28 - reftable_reader_init_ref_iterator(reader, &it);
28 + reftable_table_init_ref_iterator(table, &it);
29 ret = reftable_iterator_seek_ref(&it, "");
30 check(!ret);
31 ret = reftable_iterator_next_ref(&it, &ref);
@@ -39,12 +39,12 @@ static int t_reader_seek_once(void)
39
40 reftable_ref_record_release(&ref);
41 reftable_iterator_destroy(&it);
42 - reftable_reader_decref(reader);
42 + reftable_table_decref(table);
43 reftable_buf_release(&buf);
44 return 0;
45 }
46
47 -static int t_reader_reseek(void)
47 +static int t_table_reseek(void)
48 {
49 struct reftable_ref_record records[] = {
50 {
@@ -56,17 +56,17 @@ static int t_reader_reseek(void)
56 struct reftable_block_source source = { 0 };
57 struct reftable_ref_record ref = { 0 };
58 struct reftable_iterator it = { 0 };
59 - struct reftable_reader *reader;
59 + struct reftable_table *table;
60 struct reftable_buf buf = REFTABLE_BUF_INIT;
61 int ret;
62
63 t_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);
64 block_source_from_buf(&source, &buf);
65
66 - ret = reftable_reader_new(&reader, &source, "name");
66 + ret = reftable_table_new(&table, &source, "name");
67 check(!ret);
68
69 - reftable_reader_init_ref_iterator(reader, &it);
69 + reftable_table_init_ref_iterator(table, &it);
70
71 for (size_t i = 0; i < 5; i++) {
72 ret = reftable_iterator_seek_ref(&it, "");
@@ -83,14 +83,14 @@ static int t_reader_reseek(void)
83
84 reftable_ref_record_release(&ref);
85 reftable_iterator_destroy(&it);
86 - reftable_reader_decref(reader);
86 + reftable_table_decref(table);
87 reftable_buf_release(&buf);
88 return 0;
89 }
90
91 int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
92 {
93 - TEST(t_reader_seek_once(), "reader can seek once");
94 - TEST(t_reader_reseek(), "reader can reseek multiple times");
93 + TEST(t_table_seek_once(), "table can seek once");
94 + TEST(t_table_reseek(), "table can reseek multiple times");
95 return test_done();
96 }