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>

1 files changed, 33 insertions, 33 deletions

diff --git a/t/unit-tests/t-reftable-stack.c b/t/unit-tests/t-reftable-stack.c
index c3f0059c34..2f49c97519 100644
--- a/t/unit-tests/t-reftable-stack.c
+++ b/t/unit-tests/t-reftable-stack.c
@@ -12,9 +12,9 @@ https://developers.google.com/open-source/licenses/bsd
 #include "lib-reftable.h"
 #include "dir.h"
 #include "reftable/merged.h"
-#include "reftable/reader.h"
 #include "reftable/reftable-error.h"
 #include "reftable/stack.h"
+#include "reftable/table.h"
 #include "strbuf.h"
 #include "tempfile.h"
 #include <dirent.h>
@@ -176,7 +176,7 @@ static void t_reftable_stack_add_one(void)
 	err = reftable_stack_read_ref(st, ref.refname, &dest);
 	check(!err);
 	check(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));
-	check_int(st->readers_len, >, 0);
+	check_int(st->tables_len, >, 0);
 
 #ifndef GIT_WINDOWS_NATIVE
 	check(!reftable_buf_addstr(&scratch, dir));
@@ -189,7 +189,7 @@ static void t_reftable_stack_add_one(void)
 	check(!reftable_buf_addstr(&scratch, dir));
 	check(!reftable_buf_addstr(&scratch, "/"));
 	/* do not try at home; not an external API for reftable. */
-	check(!reftable_buf_addstr(&scratch, st->readers[0]->name));
+	check(!reftable_buf_addstr(&scratch, st->tables[0]->name));
 	err = stat(scratch.buf, &stat_result);
 	check(!err);
 	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)
 		 * all tables in the stack.
 		 */
 		if (i != n)
-			check_int(st->merged->readers_len, ==, i + 1);
+			check_int(st->merged->tables_len, ==, i + 1);
 		else
-			check_int(st->merged->readers_len, ==, 1);
+			check_int(st->merged->tables_len, ==, 1);
 	}
 
 	reftable_stack_destroy(st);
@@ -430,7 +430,7 @@ static void t_reftable_stack_auto_compaction_fails_gracefully(void)
 
 	err = reftable_stack_add(st, write_test_ref, &ref);
 	check(!err);
-	check_int(st->merged->readers_len, ==, 1);
+	check_int(st->merged->tables_len, ==, 1);
 	check_int(st->stats.attempts, ==, 0);
 	check_int(st->stats.failures, ==, 0);
 
@@ -441,14 +441,14 @@ static void t_reftable_stack_auto_compaction_fails_gracefully(void)
 	 */
 	check(!reftable_buf_addstr(&table_path, dir));
 	check(!reftable_buf_addstr(&table_path, "/"));
-	check(!reftable_buf_addstr(&table_path, st->readers[0]->name));
+	check(!reftable_buf_addstr(&table_path, st->tables[0]->name));
 	check(!reftable_buf_addstr(&table_path, ".lock"));
 	write_file_buf(table_path.buf, "", 0);
 
 	ref.update_index = 2;
 	err = reftable_stack_add(st, write_test_ref, &ref);
 	check(!err);
-	check_int(st->merged->readers_len, ==, 2);
+	check_int(st->merged->tables_len, ==, 2);
 	check_int(st->stats.attempts, ==, 1);
 	check_int(st->stats.failures, ==, 1);
 
@@ -592,7 +592,7 @@ static void t_reftable_stack_add(void)
 	check(!reftable_buf_addstr(&path, dir));
 	check(!reftable_buf_addstr(&path, "/"));
 	/* do not try at home; not an external API for reftable. */
-	check(!reftable_buf_addstr(&path, st->readers[0]->name));
+	check(!reftable_buf_addstr(&path, st->tables[0]->name));
 	err = stat(path.buf, &stat_result);
 	check(!err);
 	check_int((stat_result.st_mode & 0777), ==, opts.default_permissions);
@@ -1026,7 +1026,7 @@ static void t_reftable_stack_auto_compaction(void)
 
 		err = reftable_stack_auto_compact(st);
 		check(!err);
-		check(i < 2 || st->merged->readers_len < 2 * fastlogN(i, 2));
+		check(i < 2 || st->merged->tables_len < 2 * fastlogN(i, 2));
 	}
 
 	check_int(reftable_stack_compaction_stats(st)->entries_written, <,
@@ -1061,7 +1061,7 @@ static void t_reftable_stack_auto_compaction_factor(void)
 		err = reftable_stack_add(st, &write_test_ref, &ref);
 		check(!err);
 
-		check(i < 5 || st->merged->readers_len < 5 * fastlogN(i, 5));
+		check(i < 5 || st->merged->tables_len < 5 * fastlogN(i, 5));
 	}
 
 	reftable_stack_destroy(st);
@@ -1082,7 +1082,7 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)
 	check(!err);
 
 	write_n_ref_tables(st, 5);
-	check_int(st->merged->readers_len, ==, 5);
+	check_int(st->merged->tables_len, ==, 5);
 
 	/*
 	 * 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)
 	 */
 	check(!reftable_buf_addstr(&buf, dir));
 	check(!reftable_buf_addstr(&buf, "/"));
-	check(!reftable_buf_addstr(&buf, st->readers[2]->name));
+	check(!reftable_buf_addstr(&buf, st->tables[2]->name));
 	check(!reftable_buf_addstr(&buf, ".lock"));
 	write_file_buf(buf.buf, "", 0);
 
@@ -1104,7 +1104,7 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)
 	err = reftable_stack_auto_compact(st);
 	check(!err);
 	check_int(st->stats.failures, ==, 0);
-	check_int(st->merged->readers_len, ==, 4);
+	check_int(st->merged->tables_len, ==, 4);
 
 	reftable_stack_destroy(st);
 	reftable_buf_release(&buf);
@@ -1149,9 +1149,9 @@ static void t_reftable_stack_add_performs_auto_compaction(void)
 		 * all tables in the stack.
 		 */
 		if (i != n)
-			check_int(st->merged->readers_len, ==, i + 1);
+			check_int(st->merged->tables_len, ==, i + 1);
 		else
-			check_int(st->merged->readers_len, ==, 1);
+			check_int(st->merged->tables_len, ==, 1);
 	}
 
 	reftable_stack_destroy(st);
@@ -1172,12 +1172,12 @@ static void t_reftable_stack_compaction_with_locked_tables(void)
 	check(!err);
 
 	write_n_ref_tables(st, 3);
-	check_int(st->merged->readers_len, ==, 3);
+	check_int(st->merged->tables_len, ==, 3);
 
 	/* Lock one of the tables that we're about to compact. */
 	check(!reftable_buf_addstr(&buf, dir));
 	check(!reftable_buf_addstr(&buf, "/"));
-	check(!reftable_buf_addstr(&buf, st->readers[1]->name));
+	check(!reftable_buf_addstr(&buf, st->tables[1]->name));
 	check(!reftable_buf_addstr(&buf, ".lock"));
 	write_file_buf(buf.buf, "", 0);
 
@@ -1188,7 +1188,7 @@ static void t_reftable_stack_compaction_with_locked_tables(void)
 	err = reftable_stack_compact_all(st, NULL);
 	check_int(err, ==, REFTABLE_LOCK_ERROR);
 	check_int(st->stats.failures, ==, 1);
-	check_int(st->merged->readers_len, ==, 3);
+	check_int(st->merged->tables_len, ==, 3);
 
 	reftable_stack_destroy(st);
 	reftable_buf_release(&buf);
@@ -1222,10 +1222,10 @@ static void t_reftable_stack_compaction_concurrent(void)
 static void unclean_stack_close(struct reftable_stack *st)
 {
 	/* break abstraction boundary to simulate unclean shutdown. */
-	for (size_t i = 0; i < st->readers_len; i++)
-		reftable_reader_decref(st->readers[i]);
-	st->readers_len = 0;
-	REFTABLE_FREE_AND_NULL(st->readers);
+	for (size_t i = 0; i < st->tables_len; i++)
+		reftable_table_decref(st->tables[i]);
+	st->tables_len = 0;
+	REFTABLE_FREE_AND_NULL(st->tables);
 }
 
 static void t_reftable_stack_compaction_concurrent_clean(void)
@@ -1275,7 +1275,7 @@ static void t_reftable_stack_read_across_reload(void)
 	err = reftable_new_stack(&st1, dir, &opts);
 	check(!err);
 	write_n_ref_tables(st1, 2);
-	check_int(st1->merged->readers_len, ==, 2);
+	check_int(st1->merged->tables_len, ==, 2);
 	reftable_stack_init_ref_iterator(st1, &it);
 	err = reftable_iterator_seek_ref(&it, "");
 	check(!err);
@@ -1283,10 +1283,10 @@ static void t_reftable_stack_read_across_reload(void)
 	/* Set up a second stack for the same directory and compact it. */
 	err = reftable_new_stack(&st2, dir, &opts);
 	check(!err);
-	check_int(st2->merged->readers_len, ==, 2);
+	check_int(st2->merged->tables_len, ==, 2);
 	err = reftable_stack_compact_all(st2, NULL);
 	check(!err);
-	check_int(st2->merged->readers_len, ==, 1);
+	check_int(st2->merged->tables_len, ==, 1);
 
 	/*
 	 * 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)
 	 */
 	err = reftable_stack_reload(st1);
 	check(!err);
-	check_int(st1->merged->readers_len, ==, 1);
+	check_int(st1->merged->tables_len, ==, 1);
 	err = reftable_iterator_next_ref(&it, &rec);
 	check(!err);
 	check_str(rec.refname, "refs/heads/branch-0000");
@@ -1325,19 +1325,19 @@ static void t_reftable_stack_reload_with_missing_table(void)
 	err = reftable_new_stack(&st, dir, &opts);
 	check(!err);
 	write_n_ref_tables(st, 2);
-	check_int(st->merged->readers_len, ==, 2);
+	check_int(st->merged->tables_len, ==, 2);
 	reftable_stack_init_ref_iterator(st, &it);
 	err = reftable_iterator_seek_ref(&it, "");
 	check(!err);
 
 	/*
 	 * Update the tables.list file with some garbage data, while reusing
-	 * our old readers. This should trigger a partial reload of the stack,
-	 * where we try to reuse our old readers.
+	 * our old tables. This should trigger a partial reload of the stack,
+	 * where we try to reuse our old tables.
 	*/
-	check(!reftable_buf_addstr(&content, st->readers[0]->name));
+	check(!reftable_buf_addstr(&content, st->tables[0]->name));
 	check(!reftable_buf_addstr(&content, "\n"));
-	check(!reftable_buf_addstr(&content, st->readers[1]->name));
+	check(!reftable_buf_addstr(&content, st->tables[1]->name));
 	check(!reftable_buf_addstr(&content, "\n"));
 	check(!reftable_buf_addstr(&content, "garbage\n"));
 	check(!reftable_buf_addstr(&table_path, st->list_file));
@@ -1348,7 +1348,7 @@ static void t_reftable_stack_reload_with_missing_table(void)
 
 	err = reftable_stack_reload(st);
 	check_int(err, ==, -4);
-	check_int(st->merged->readers_len, ==, 2);
+	check_int(st->merged->tables_len, ==, 2);
 
 	/*
 	 * Even though the reload has failed, we should be able to continue