reftable/generic: drop interface

The `reftable_table` interface provides a generic infrastructure that
can abstract away whether the underlying table is a single table, or a
merged table. This abstraction can make it rather hard to reason about
the code. We didn't ever use it to implement the reftable backend, and
with the preceding patches in this patch series we in fact don't use it
at all anymore. Furthermore, it became somewhat useless with the recent
refactorings that made it possible to seek reftable iterators multiple
times, as these now provide generic access to tables for us. The
interface is thus redundant and only brings unnecessary complexity with
it.

Remove the `struct reftable_table` interface and its associated
functions.

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

diff --git a/Makefile b/Makefile
index 343f19a488b0f329a53809496e649d678668e5ef..41dfa0bad2cc8a38a5516ae9ca31ebcd680072be 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -2674,7 +2674,6 @@ REFTABLE_OBJS += reftable/merged.o
 REFTABLE_OBJS += reftable/pq.o
 REFTABLE_OBJS += reftable/reader.o
 REFTABLE_OBJS += reftable/record.o
-REFTABLE_OBJS += reftable/generic.o
 REFTABLE_OBJS += reftable/stack.o
 REFTABLE_OBJS += reftable/tree.o
 REFTABLE_OBJS += reftable/writer.o

diff --git a/reftable/generic.c b/reftable/generic.c
deleted file mode 100644 (file)
index 495ee9a..0000000
--- a/reftable/generic.c
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
-Copyright 2020 Google LLC
-
-Use of this source code is governed by a BSD-style
-license that can be found in the LICENSE file or at
-https://developers.google.com/open-source/licenses/bsd
-*/
-
-#include "constants.h"
-#include "record.h"
-#include "generic.h"
-#include "iter.h"
-#include "reftable-iterator.h"
-#include "reftable-generic.h"
-
-void table_init_iter(struct reftable_table *tab,
-                    struct reftable_iterator *it,
-                    uint8_t typ)
-{
-
-       tab->ops->init_iter(tab->table_arg, it, typ);
-}
-
-void reftable_table_init_ref_iter(struct reftable_table *tab,
-                                 struct reftable_iterator *it)
-{
-       table_init_iter(tab, it, BLOCK_TYPE_REF);
-}
-
-void reftable_table_init_log_iter(struct reftable_table *tab,
-                                 struct reftable_iterator *it)
-{
-       table_init_iter(tab, it, BLOCK_TYPE_LOG);
-}
-
-int reftable_table_read_ref(struct reftable_table *tab, const char *name,
-                           struct reftable_ref_record *ref)
-{
-       struct reftable_iterator it = { NULL };
-       int err;
-
-       reftable_table_init_ref_iter(tab, &it);
-
-       err = reftable_iterator_seek_ref(&it, name);
-       if (err)
-               goto done;
-
-       err = reftable_iterator_next_ref(&it, ref);
-       if (err)
-               goto done;
-
-       if (strcmp(ref->refname, name) ||
-           reftable_ref_record_is_deletion(ref)) {
-               reftable_ref_record_release(ref);
-               err = 1;
-               goto done;
-       }
-
-done:
-       reftable_iterator_destroy(&it);
-       return err;
-}
-
-uint64_t reftable_table_max_update_index(struct reftable_table *tab)
-{
-       return tab->ops->max_update_index(tab->table_arg);
-}
-
-uint64_t reftable_table_min_update_index(struct reftable_table *tab)
-{
-       return tab->ops->min_update_index(tab->table_arg);
-}
-
-uint32_t reftable_table_hash_id(struct reftable_table *tab)
-{
-       return tab->ops->hash_id(tab->table_arg);
-}

diff --git a/reftable/generic.h b/reftable/generic.h
deleted file mode 100644 (file)
index 837fbb8..0000000
--- a/reftable/generic.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
-Copyright 2020 Google LLC
-
-Use of this source code is governed by a BSD-style
-license that can be found in the LICENSE file or at
-https://developers.google.com/open-source/licenses/bsd
-*/
-
-#ifndef GENERIC_H
-#define GENERIC_H
-
-#include "record.h"
-#include "reftable-generic.h"
-
-/* generic interface to reftables */
-struct reftable_table_vtable {
-       void (*init_iter)(void *tab, struct reftable_iterator *it, uint8_t typ);
-       uint32_t (*hash_id)(void *tab);
-       uint64_t (*min_update_index)(void *tab);
-       uint64_t (*max_update_index)(void *tab);
-};
-
-void table_init_iter(struct reftable_table *tab,
-                    struct reftable_iterator *it,
-                    uint8_t typ);
-
-#endif

diff --git a/reftable/iter.c b/reftable/iter.c
index 225feb78714f4db0d8e23f64272ddf00c354002f..97a4642ed571704e706a65c0ef5c3d07fb6ca719 100644 (file)
--- a/reftable/iter.c
+++ b/reftable/iter.c
@@ -11,7 +11,6 @@ https://developers.google.com/open-source/licenses/bsd
 #include "system.h"
 
 #include "block.h"
-#include "generic.h"
 #include "constants.h"
 #include "reader.h"
 #include "reftable-error.h"

diff --git a/reftable/iter.h b/reftable/iter.h
index 3b401f12590cb074b63297356ab306e545682df9..befc4597df14c9c7b3ba1f25aa34021834eaad97 100644 (file)
--- a/reftable/iter.h
+++ b/reftable/iter.h
@@ -14,7 +14,6 @@ https://developers.google.com/open-source/licenses/bsd
 #include "record.h"
 
 #include "reftable-iterator.h"
-#include "reftable-generic.h"
 
 /*
  * The virtual function table for implementing generic reftable iterators.

diff --git a/reftable/merged.c b/reftable/merged.c
index 2e72eab306971a0bbd9dc4a04c906f34a34fdf21..128a810c55dd079317107bce90d287679f525394 100644 (file)
--- a/reftable/merged.c
+++ b/reftable/merged.c
@@ -13,7 +13,6 @@ https://developers.google.com/open-source/licenses/bsd
 #include "pq.h"
 #include "reader.h"
 #include "record.h"
-#include "generic.h"
 #include "reftable-merged.h"
 #include "reftable-error.h"
 #include "system.h"
@@ -270,40 +269,3 @@ uint32_t reftable_merged_table_hash_id(struct reftable_merged_table *mt)
 {
        return mt->hash_id;
 }
-
-static void reftable_merged_table_init_iter_void(void *tab,
-                                                struct reftable_iterator *it,
-                                                uint8_t typ)
-{
-       merged_table_init_iter(tab, it, typ);
-}
-
-static uint32_t reftable_merged_table_hash_id_void(void *tab)
-{
-       return reftable_merged_table_hash_id(tab);
-}
-
-static uint64_t reftable_merged_table_min_update_index_void(void *tab)
-{
-       return reftable_merged_table_min_update_index(tab);
-}
-
-static uint64_t reftable_merged_table_max_update_index_void(void *tab)
-{
-       return reftable_merged_table_max_update_index(tab);
-}
-
-static struct reftable_table_vtable merged_table_vtable = {
-       .init_iter = reftable_merged_table_init_iter_void,
-       .hash_id = reftable_merged_table_hash_id_void,
-       .min_update_index = reftable_merged_table_min_update_index_void,
-       .max_update_index = reftable_merged_table_max_update_index_void,
-};
-
-void reftable_table_from_merged_table(struct reftable_table *tab,
-                                     struct reftable_merged_table *merged)
-{
-       assert(!tab->ops);
-       tab->ops = &merged_table_vtable;
-       tab->table_arg = merged;
-}

diff --git a/reftable/reader.c b/reftable/reader.c
index fbd93b88dff69e7bcc7edb4ccaadef193f5ec967..082cf00b60658397ba278fc75d92fb51e1254c76 100644 (file)
--- a/reftable/reader.c
+++ b/reftable/reader.c
@@ -11,11 +11,9 @@ https://developers.google.com/open-source/licenses/bsd
 #include "system.h"
 #include "block.h"
 #include "constants.h"
-#include "generic.h"
 #include "iter.h"
 #include "record.h"
 #include "reftable-error.h"
-#include "reftable-generic.h"
 
 uint64_t block_source_size(struct reftable_block_source *source)
 {
@@ -759,45 +757,6 @@ uint64_t reftable_reader_min_update_index(struct reftable_reader *r)
        return r->min_update_index;
 }
 
-/* generic table interface. */
-
-static void reftable_reader_init_iter_void(void *tab,
-                                          struct reftable_iterator *it,
-                                          uint8_t typ)
-{
-       reader_init_iter(tab, it, typ);
-}
-
-static uint32_t reftable_reader_hash_id_void(void *tab)
-{
-       return reftable_reader_hash_id(tab);
-}
-
-static uint64_t reftable_reader_min_update_index_void(void *tab)
-{
-       return reftable_reader_min_update_index(tab);
-}
-
-static uint64_t reftable_reader_max_update_index_void(void *tab)
-{
-       return reftable_reader_max_update_index(tab);
-}
-
-static struct reftable_table_vtable reader_vtable = {
-       .init_iter = reftable_reader_init_iter_void,
-       .hash_id = reftable_reader_hash_id_void,
-       .min_update_index = reftable_reader_min_update_index_void,
-       .max_update_index = reftable_reader_max_update_index_void,
-};
-
-void reftable_table_from_reader(struct reftable_table *tab,
-                               struct reftable_reader *reader)
-{
-       assert(!tab->ops);
-       tab->ops = &reader_vtable;
-       tab->table_arg = reader;
-}
-
 int reftable_reader_print_blocks(const char *tablename)
 {
        struct {

diff --git a/reftable/reftable-generic.h b/reftable/reftable-generic.h
deleted file mode 100644 (file)
index b8b1323..0000000
--- a/reftable/reftable-generic.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
-Copyright 2020 Google LLC
-
-Use of this source code is governed by a BSD-style
-license that can be found in the LICENSE file or at
-https://developers.google.com/open-source/licenses/bsd
-*/
-
-#ifndef REFTABLE_GENERIC_H
-#define REFTABLE_GENERIC_H
-
-#include "reftable-iterator.h"
-
-struct reftable_table_vtable;
-
-/*
- * Provides a unified API for reading tables, either merged tables, or single
- * readers. */
-struct reftable_table {
-       struct reftable_table_vtable *ops;
-       void *table_arg;
-};
-
-void reftable_table_init_ref_iter(struct reftable_table *tab,
-                                 struct reftable_iterator *it);
-
-void reftable_table_init_log_iter(struct reftable_table *tab,
-                                 struct reftable_iterator *it);
-
-/* returns the hash ID from a generic reftable_table */
-uint32_t reftable_table_hash_id(struct reftable_table *tab);
-
-/* returns the max update_index covered by this table. */
-uint64_t reftable_table_max_update_index(struct reftable_table *tab);
-
-/* returns the min update_index covered by this table. */
-uint64_t reftable_table_min_update_index(struct reftable_table *tab);
-
-/* convenience function to read a single ref. Returns < 0 for error, 0
-   for success, and 1 if ref not found. */
-int reftable_table_read_ref(struct reftable_table *tab, const char *name,
-                           struct reftable_ref_record *ref);
-
-#endif

diff --git a/reftable/reftable-merged.h b/reftable/reftable-merged.h
index 03c2619c0ff4507a77334c11dbe52a6dcc78fb97..16d19f8df206f3540cb471a12fa9060e2e8863f8 100644 (file)
--- a/reftable/reftable-merged.h
+++ b/reftable/reftable-merged.h
@@ -26,8 +26,6 @@ https://developers.google.com/open-source/licenses/bsd
 /* A merged table is implements seeking/iterating over a stack of tables. */
 struct reftable_merged_table;
 
-/* A generic reftable; see below. */
-struct reftable_table;
 struct reftable_reader;
 
 /*
@@ -60,8 +58,4 @@ void reftable_merged_table_free(struct reftable_merged_table *m);
 /* return the hash ID of the merged table. */
 uint32_t reftable_merged_table_hash_id(struct reftable_merged_table *m);
 
-/* create a generic table from reftable_merged_table */
-void reftable_table_from_merged_table(struct reftable_table *tab,
-                                     struct reftable_merged_table *table);
-
 #endif

diff --git a/reftable/reftable-reader.h b/reftable/reftable-reader.h
index 7c7d17165168a6451ae0f7f044885dbb323cf5ba..69621c5b0fc7f9e753a72bae6821ee770d1323f9 100644 (file)
--- a/reftable/reftable-reader.h
+++ b/reftable/reftable-reader.h
@@ -23,9 +23,6 @@
 /* The reader struct is a handle to an open reftable file. */
 struct reftable_reader;
 
-/* Generic table. */
-struct reftable_table;
-
 /* reftable_new_reader opens a reftable for reading. If successful,
  * returns 0 code and sets pp. The name is used for creating a
  * stack. Typically, it is the basename of the file. The block source
@@ -60,10 +57,6 @@ uint64_t reftable_reader_max_update_index(struct reftable_reader *r);
 /* return the min_update_index for a table */
 uint64_t reftable_reader_min_update_index(struct reftable_reader *r);
 
-/* creates a generic table from a file reader. */
-void reftable_table_from_reader(struct reftable_table *tab,
-                               struct reftable_reader *reader);
-
 /* print blocks onto stdout for debugging. */
 int reftable_reader_print_blocks(const char *tablename);
 

diff --git a/reftable/stack.c b/reftable/stack.c
index bedd503e7e1fd26a417fa8fb828b75c9f7bd181b..d3a95d2f1d75c9493adf921c8b2fa33d3381e22f 100644 (file)
--- a/reftable/stack.c
+++ b/reftable/stack.c
@@ -14,7 +14,6 @@ https://developers.google.com/open-source/licenses/bsd
 #include "merged.h"
 #include "reader.h"
 #include "reftable-error.h"
-#include "reftable-generic.h"
 #include "reftable-record.h"
 #include "reftable-merged.h"
 #include "writer.h"

diff --git a/t/unit-tests/t-reftable-merged.c b/t/unit-tests/t-reftable-merged.c
index 577b1a5be8731f9f0d3c6fbc6ed512d89cf79d91..93345c6c8bec1cd2d0df8a13bb02a9a44846e0ad 100644 (file)
--- a/t/unit-tests/t-reftable-merged.c
+++ b/t/unit-tests/t-reftable-merged.c
@@ -12,7 +12,6 @@ https://developers.google.com/open-source/licenses/bsd
 #include "reftable/merged.h"
 #include "reftable/reader.h"
 #include "reftable/reftable-error.h"
-#include "reftable/reftable-generic.h"
 #include "reftable/reftable-merged.h"
 #include "reftable/reftable-writer.h"