mirror of
https://github.com/git/git.git
synced 2024-10-28 12:59:41 +01:00
reftable/record: improve semantics when initializing records
According to our usual coding style, the `reftable_new_record()` function would indicate that it is allocating a new record. This is not the case though as the function merely initializes records without allocating any memory. Replace `reftable_new_record()` with a new `reftable_record_init()` function that takes a record pointer as input and initializes it accordingly. Signed-off-by: Patrick Steinhardt <ps@pks.im> Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
parent
62d3c8e8c8
commit
3ddef475d0
6 changed files with 33 additions and 54 deletions
|
@ -382,23 +382,23 @@ int block_reader_seek(struct block_reader *br, struct block_iter *it,
|
||||||
.key = *want,
|
.key = *want,
|
||||||
.r = br,
|
.r = br,
|
||||||
};
|
};
|
||||||
struct reftable_record rec = reftable_new_record(block_reader_type(br));
|
|
||||||
int err = 0;
|
|
||||||
struct block_iter next = BLOCK_ITER_INIT;
|
struct block_iter next = BLOCK_ITER_INIT;
|
||||||
|
struct reftable_record rec;
|
||||||
|
int err = 0, i;
|
||||||
|
|
||||||
int i = binsearch(br->restart_count, &restart_key_less, &args);
|
|
||||||
if (args.error) {
|
if (args.error) {
|
||||||
err = REFTABLE_FORMAT_ERROR;
|
err = REFTABLE_FORMAT_ERROR;
|
||||||
goto done;
|
goto done;
|
||||||
}
|
}
|
||||||
|
|
||||||
it->br = br;
|
i = binsearch(br->restart_count, &restart_key_less, &args);
|
||||||
if (i > 0) {
|
if (i > 0)
|
||||||
i--;
|
it->next_off = block_reader_restart_offset(br, i - 1);
|
||||||
it->next_off = block_reader_restart_offset(br, i);
|
else
|
||||||
} else {
|
|
||||||
it->next_off = br->header_off + 4;
|
it->next_off = br->header_off + 4;
|
||||||
}
|
it->br = br;
|
||||||
|
|
||||||
|
reftable_record_init(&rec, block_reader_type(br));
|
||||||
|
|
||||||
/* We're looking for the last entry less/equal than the wanted key, so
|
/* We're looking for the last entry less/equal than the wanted key, so
|
||||||
we have to go one entry too far and then back up.
|
we have to go one entry too far and then back up.
|
||||||
|
|
|
@ -21,11 +21,11 @@ static int merged_iter_init(struct merged_iter *mi)
|
||||||
{
|
{
|
||||||
for (size_t i = 0; i < mi->stack_len; i++) {
|
for (size_t i = 0; i < mi->stack_len; i++) {
|
||||||
struct pq_entry e = {
|
struct pq_entry e = {
|
||||||
.rec = reftable_new_record(mi->typ),
|
|
||||||
.index = i,
|
.index = i,
|
||||||
};
|
};
|
||||||
int err;
|
int err;
|
||||||
|
|
||||||
|
reftable_record_init(&e.rec, mi->typ);
|
||||||
err = iterator_next(&mi->stack[i], &e.rec);
|
err = iterator_next(&mi->stack[i], &e.rec);
|
||||||
if (err < 0)
|
if (err < 0)
|
||||||
return err;
|
return err;
|
||||||
|
@ -57,10 +57,12 @@ static int merged_iter_advance_nonnull_subiter(struct merged_iter *mi,
|
||||||
size_t idx)
|
size_t idx)
|
||||||
{
|
{
|
||||||
struct pq_entry e = {
|
struct pq_entry e = {
|
||||||
.rec = reftable_new_record(mi->typ),
|
|
||||||
.index = idx,
|
.index = idx,
|
||||||
};
|
};
|
||||||
int err = iterator_next(&mi->stack[idx], &e.rec);
|
int err;
|
||||||
|
|
||||||
|
reftable_record_init(&e.rec, mi->typ);
|
||||||
|
err = iterator_next(&mi->stack[idx], &e.rec);
|
||||||
if (err < 0)
|
if (err < 0)
|
||||||
return err;
|
return err;
|
||||||
|
|
||||||
|
|
|
@ -444,13 +444,13 @@ static int reader_start(struct reftable_reader *r, struct table_iter *ti,
|
||||||
static int reader_seek_linear(struct table_iter *ti,
|
static int reader_seek_linear(struct table_iter *ti,
|
||||||
struct reftable_record *want)
|
struct reftable_record *want)
|
||||||
{
|
{
|
||||||
struct reftable_record rec =
|
|
||||||
reftable_new_record(reftable_record_type(want));
|
|
||||||
struct strbuf want_key = STRBUF_INIT;
|
struct strbuf want_key = STRBUF_INIT;
|
||||||
struct strbuf got_key = STRBUF_INIT;
|
struct strbuf got_key = STRBUF_INIT;
|
||||||
struct table_iter next = TABLE_ITER_INIT;
|
struct table_iter next = TABLE_ITER_INIT;
|
||||||
|
struct reftable_record rec;
|
||||||
int err = -1;
|
int err = -1;
|
||||||
|
|
||||||
|
reftable_record_init(&rec, reftable_record_type(want));
|
||||||
reftable_record_key(want, &want_key);
|
reftable_record_key(want, &want_key);
|
||||||
|
|
||||||
while (1) {
|
while (1) {
|
||||||
|
|
|
@ -1259,45 +1259,22 @@ reftable_record_vtable(struct reftable_record *rec)
|
||||||
abort();
|
abort();
|
||||||
}
|
}
|
||||||
|
|
||||||
struct reftable_record reftable_new_record(uint8_t typ)
|
void reftable_record_init(struct reftable_record *rec, uint8_t typ)
|
||||||
{
|
{
|
||||||
struct reftable_record clean = {
|
memset(rec, 0, sizeof(*rec));
|
||||||
.type = typ,
|
rec->type = typ;
|
||||||
};
|
|
||||||
|
|
||||||
/* the following is involved, but the naive solution (just return
|
|
||||||
* `clean` as is, except for BLOCK_TYPE_INDEX), returns a garbage
|
|
||||||
* clean.u.obj.offsets pointer on Windows VS CI. Go figure.
|
|
||||||
*/
|
|
||||||
switch (typ) {
|
switch (typ) {
|
||||||
case BLOCK_TYPE_OBJ:
|
|
||||||
{
|
|
||||||
struct reftable_obj_record obj = { 0 };
|
|
||||||
clean.u.obj = obj;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case BLOCK_TYPE_INDEX:
|
|
||||||
{
|
|
||||||
struct reftable_index_record idx = {
|
|
||||||
.last_key = STRBUF_INIT,
|
|
||||||
};
|
|
||||||
clean.u.idx = idx;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case BLOCK_TYPE_REF:
|
case BLOCK_TYPE_REF:
|
||||||
{
|
|
||||||
struct reftable_ref_record ref = { 0 };
|
|
||||||
clean.u.ref = ref;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case BLOCK_TYPE_LOG:
|
case BLOCK_TYPE_LOG:
|
||||||
{
|
case BLOCK_TYPE_OBJ:
|
||||||
struct reftable_log_record log = { 0 };
|
return;
|
||||||
clean.u.log = log;
|
case BLOCK_TYPE_INDEX:
|
||||||
break;
|
strbuf_init(&rec->u.idx.last_key, 0);
|
||||||
|
return;
|
||||||
|
default:
|
||||||
|
BUG("unhandled record type");
|
||||||
}
|
}
|
||||||
}
|
|
||||||
return clean;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void reftable_record_print(struct reftable_record *rec, int hash_size)
|
void reftable_record_print(struct reftable_record *rec, int hash_size)
|
||||||
|
|
|
@ -69,9 +69,6 @@ struct reftable_record_vtable {
|
||||||
/* returns true for recognized block types. Block start with the block type. */
|
/* returns true for recognized block types. Block start with the block type. */
|
||||||
int reftable_is_block_type(uint8_t typ);
|
int reftable_is_block_type(uint8_t typ);
|
||||||
|
|
||||||
/* return an initialized record for the given type */
|
|
||||||
struct reftable_record reftable_new_record(uint8_t typ);
|
|
||||||
|
|
||||||
/* Encode `key` into `dest`. Sets `is_restart` to indicate a restart. Returns
|
/* Encode `key` into `dest`. Sets `is_restart` to indicate a restart. Returns
|
||||||
* number of bytes written. */
|
* number of bytes written. */
|
||||||
int reftable_encode_key(int *is_restart, struct string_view dest,
|
int reftable_encode_key(int *is_restart, struct string_view dest,
|
||||||
|
@ -100,8 +97,8 @@ struct reftable_obj_record {
|
||||||
/* record is a generic wrapper for different types of records. It is normally
|
/* record is a generic wrapper for different types of records. It is normally
|
||||||
* created on the stack, or embedded within another struct. If the type is
|
* created on the stack, or embedded within another struct. If the type is
|
||||||
* known, a fresh instance can be initialized explicitly. Otherwise, use
|
* known, a fresh instance can be initialized explicitly. Otherwise, use
|
||||||
* reftable_new_record() to initialize generically (as the index_record is not
|
* `reftable_record_init()` to initialize generically (as the index_record is
|
||||||
* valid as 0-initialized structure)
|
* not valid as 0-initialized structure)
|
||||||
*/
|
*/
|
||||||
struct reftable_record {
|
struct reftable_record {
|
||||||
uint8_t type;
|
uint8_t type;
|
||||||
|
@ -113,6 +110,9 @@ struct reftable_record {
|
||||||
} u;
|
} u;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
/* Initialize the reftable record for the given type */
|
||||||
|
void reftable_record_init(struct reftable_record *rec, uint8_t typ);
|
||||||
|
|
||||||
/* see struct record_vtable */
|
/* see struct record_vtable */
|
||||||
int reftable_record_equal(struct reftable_record *a, struct reftable_record *b, int hash_size);
|
int reftable_record_equal(struct reftable_record *a, struct reftable_record *b, int hash_size);
|
||||||
void reftable_record_print(struct reftable_record *rec, int hash_size);
|
void reftable_record_print(struct reftable_record *rec, int hash_size);
|
||||||
|
|
|
@ -16,11 +16,11 @@
|
||||||
|
|
||||||
static void test_copy(struct reftable_record *rec)
|
static void test_copy(struct reftable_record *rec)
|
||||||
{
|
{
|
||||||
struct reftable_record copy = { 0 };
|
struct reftable_record copy;
|
||||||
uint8_t typ;
|
uint8_t typ;
|
||||||
|
|
||||||
typ = reftable_record_type(rec);
|
typ = reftable_record_type(rec);
|
||||||
copy = reftable_new_record(typ);
|
reftable_record_init(©, typ);
|
||||||
reftable_record_copy_from(©, rec, GIT_SHA1_RAWSZ);
|
reftable_record_copy_from(©, rec, GIT_SHA1_RAWSZ);
|
||||||
/* do it twice to catch memory leaks */
|
/* do it twice to catch memory leaks */
|
||||||
reftable_record_copy_from(©, rec, GIT_SHA1_RAWSZ);
|
reftable_record_copy_from(©, rec, GIT_SHA1_RAWSZ);
|
||||||
|
|
Loading…
Reference in a new issue