mirror of
https://github.com/git/git.git
synced 2024-10-28 21:07:52 +01:00
6014639837
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>
287 lines
6.3 KiB
C
287 lines
6.3 KiB
C
/*
|
|
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 "iter.h"
|
|
|
|
#include "system.h"
|
|
|
|
#include "block.h"
|
|
#include "constants.h"
|
|
#include "reader.h"
|
|
#include "reftable-error.h"
|
|
|
|
int iterator_seek(struct reftable_iterator *it, struct reftable_record *want)
|
|
{
|
|
return it->ops->seek(it->iter_arg, want);
|
|
}
|
|
|
|
int iterator_next(struct reftable_iterator *it, struct reftable_record *rec)
|
|
{
|
|
return it->ops->next(it->iter_arg, rec);
|
|
}
|
|
|
|
static int empty_iterator_seek(void *arg, struct reftable_record *want)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static int empty_iterator_next(void *arg, struct reftable_record *rec)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
static void empty_iterator_close(void *arg)
|
|
{
|
|
}
|
|
|
|
static struct reftable_iterator_vtable empty_vtable = {
|
|
.seek = &empty_iterator_seek,
|
|
.next = &empty_iterator_next,
|
|
.close = &empty_iterator_close,
|
|
};
|
|
|
|
void iterator_set_empty(struct reftable_iterator *it)
|
|
{
|
|
assert(!it->ops);
|
|
it->iter_arg = NULL;
|
|
it->ops = &empty_vtable;
|
|
}
|
|
|
|
static void filtering_ref_iterator_close(void *iter_arg)
|
|
{
|
|
struct filtering_ref_iterator *fri = iter_arg;
|
|
strbuf_release(&fri->oid);
|
|
reftable_iterator_destroy(&fri->it);
|
|
}
|
|
|
|
static int filtering_ref_iterator_seek(void *iter_arg,
|
|
struct reftable_record *want)
|
|
{
|
|
struct filtering_ref_iterator *fri = iter_arg;
|
|
return iterator_seek(&fri->it, want);
|
|
}
|
|
|
|
static int filtering_ref_iterator_next(void *iter_arg,
|
|
struct reftable_record *rec)
|
|
{
|
|
struct filtering_ref_iterator *fri = iter_arg;
|
|
struct reftable_ref_record *ref = &rec->u.ref;
|
|
int err = 0;
|
|
while (1) {
|
|
err = reftable_iterator_next_ref(&fri->it, ref);
|
|
if (err != 0) {
|
|
break;
|
|
}
|
|
|
|
if (ref->value_type == REFTABLE_REF_VAL2 &&
|
|
(!memcmp(fri->oid.buf, ref->value.val2.target_value,
|
|
fri->oid.len) ||
|
|
!memcmp(fri->oid.buf, ref->value.val2.value,
|
|
fri->oid.len)))
|
|
return 0;
|
|
|
|
if (ref->value_type == REFTABLE_REF_VAL1 &&
|
|
!memcmp(fri->oid.buf, ref->value.val1, fri->oid.len)) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
reftable_ref_record_release(ref);
|
|
return err;
|
|
}
|
|
|
|
static struct reftable_iterator_vtable filtering_ref_iterator_vtable = {
|
|
.seek = &filtering_ref_iterator_seek,
|
|
.next = &filtering_ref_iterator_next,
|
|
.close = &filtering_ref_iterator_close,
|
|
};
|
|
|
|
void iterator_from_filtering_ref_iterator(struct reftable_iterator *it,
|
|
struct filtering_ref_iterator *fri)
|
|
{
|
|
assert(!it->ops);
|
|
it->iter_arg = fri;
|
|
it->ops = &filtering_ref_iterator_vtable;
|
|
}
|
|
|
|
static void indexed_table_ref_iter_close(void *p)
|
|
{
|
|
struct indexed_table_ref_iter *it = p;
|
|
block_iter_close(&it->cur);
|
|
reftable_block_done(&it->block_reader.block);
|
|
reftable_free(it->offsets);
|
|
strbuf_release(&it->oid);
|
|
}
|
|
|
|
static int indexed_table_ref_iter_next_block(struct indexed_table_ref_iter *it)
|
|
{
|
|
uint64_t off;
|
|
int err = 0;
|
|
if (it->offset_idx == it->offset_len) {
|
|
it->is_finished = 1;
|
|
return 1;
|
|
}
|
|
|
|
reftable_block_done(&it->block_reader.block);
|
|
|
|
off = it->offsets[it->offset_idx++];
|
|
err = reader_init_block_reader(it->r, &it->block_reader, off,
|
|
BLOCK_TYPE_REF);
|
|
if (err < 0) {
|
|
return err;
|
|
}
|
|
if (err > 0) {
|
|
/* indexed block does not exist. */
|
|
return REFTABLE_FORMAT_ERROR;
|
|
}
|
|
block_iter_seek_start(&it->cur, &it->block_reader);
|
|
return 0;
|
|
}
|
|
|
|
static int indexed_table_ref_iter_seek(void *p, struct reftable_record *want)
|
|
{
|
|
BUG("seeking indexed table is not supported");
|
|
return -1;
|
|
}
|
|
|
|
static int indexed_table_ref_iter_next(void *p, struct reftable_record *rec)
|
|
{
|
|
struct indexed_table_ref_iter *it = p;
|
|
struct reftable_ref_record *ref = &rec->u.ref;
|
|
|
|
while (1) {
|
|
int err = block_iter_next(&it->cur, rec);
|
|
if (err < 0) {
|
|
return err;
|
|
}
|
|
|
|
if (err > 0) {
|
|
err = indexed_table_ref_iter_next_block(it);
|
|
if (err < 0) {
|
|
return err;
|
|
}
|
|
|
|
if (it->is_finished) {
|
|
return 1;
|
|
}
|
|
continue;
|
|
}
|
|
/* BUG */
|
|
if (!memcmp(it->oid.buf, ref->value.val2.target_value,
|
|
it->oid.len) ||
|
|
!memcmp(it->oid.buf, ref->value.val2.value, it->oid.len)) {
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
int new_indexed_table_ref_iter(struct indexed_table_ref_iter **dest,
|
|
struct reftable_reader *r, uint8_t *oid,
|
|
int oid_len, uint64_t *offsets, int offset_len)
|
|
{
|
|
struct indexed_table_ref_iter empty = INDEXED_TABLE_REF_ITER_INIT;
|
|
struct indexed_table_ref_iter *itr = reftable_calloc(1, sizeof(*itr));
|
|
int err = 0;
|
|
|
|
*itr = empty;
|
|
itr->r = r;
|
|
strbuf_add(&itr->oid, oid, oid_len);
|
|
|
|
itr->offsets = offsets;
|
|
itr->offset_len = offset_len;
|
|
|
|
err = indexed_table_ref_iter_next_block(itr);
|
|
if (err < 0) {
|
|
reftable_free(itr);
|
|
} else {
|
|
*dest = itr;
|
|
}
|
|
return err;
|
|
}
|
|
|
|
static struct reftable_iterator_vtable indexed_table_ref_iter_vtable = {
|
|
.seek = &indexed_table_ref_iter_seek,
|
|
.next = &indexed_table_ref_iter_next,
|
|
.close = &indexed_table_ref_iter_close,
|
|
};
|
|
|
|
void iterator_from_indexed_table_ref_iter(struct reftable_iterator *it,
|
|
struct indexed_table_ref_iter *itr)
|
|
{
|
|
assert(!it->ops);
|
|
it->iter_arg = itr;
|
|
it->ops = &indexed_table_ref_iter_vtable;
|
|
}
|
|
|
|
void reftable_iterator_destroy(struct reftable_iterator *it)
|
|
{
|
|
if (!it->ops)
|
|
return;
|
|
it->ops->close(it->iter_arg);
|
|
it->ops = NULL;
|
|
FREE_AND_NULL(it->iter_arg);
|
|
}
|
|
|
|
int reftable_iterator_seek_ref(struct reftable_iterator *it,
|
|
const char *name)
|
|
{
|
|
struct reftable_record want = {
|
|
.type = BLOCK_TYPE_REF,
|
|
.u.ref = {
|
|
.refname = (char *)name,
|
|
},
|
|
};
|
|
return it->ops->seek(it->iter_arg, &want);
|
|
}
|
|
|
|
int reftable_iterator_next_ref(struct reftable_iterator *it,
|
|
struct reftable_ref_record *ref)
|
|
{
|
|
struct reftable_record rec = {
|
|
.type = BLOCK_TYPE_REF,
|
|
.u = {
|
|
.ref = *ref
|
|
},
|
|
};
|
|
int err = iterator_next(it, &rec);
|
|
*ref = rec.u.ref;
|
|
return err;
|
|
}
|
|
|
|
int reftable_iterator_seek_log_at(struct reftable_iterator *it,
|
|
const char *name, uint64_t update_index)
|
|
{
|
|
struct reftable_record want = {
|
|
.type = BLOCK_TYPE_LOG,
|
|
.u.log = {
|
|
.refname = (char *)name,
|
|
.update_index = update_index,
|
|
},
|
|
};
|
|
return it->ops->seek(it->iter_arg, &want);
|
|
}
|
|
|
|
int reftable_iterator_seek_log(struct reftable_iterator *it,
|
|
const char *name)
|
|
{
|
|
return reftable_iterator_seek_log_at(it, name, ~((uint64_t) 0));
|
|
}
|
|
|
|
int reftable_iterator_next_log(struct reftable_iterator *it,
|
|
struct reftable_log_record *log)
|
|
{
|
|
struct reftable_record rec = {
|
|
.type = BLOCK_TYPE_LOG,
|
|
.u = {
|
|
.log = *log,
|
|
},
|
|
};
|
|
int err = iterator_next(it, &rec);
|
|
*log = rec.u.log;
|
|
return err;
|
|
}
|