@matheusbsbs / matheus-bagliano / commits / be4c070a3c

reftable: convert from `strbuf` to `reftable_buf`

Convert the reftable library to use the `reftable_buf` interface instead of the `strbuf` interface. This is mostly a mechanical change via sed(1) with some manual fixes where functions for `strbuf` and `reftable_buf` differ. The converted code does not yet handle allocation failures. This will be handled in subsequent commits. Signed-off-by: Patrick Steinhardt <ps@pks.im> Signed-off-by: Taylor Blau <me@ttaylorr.com>

Patrick Steinhardt committed Oct 17, 2024 at 06:53 UTC be4c070a3c9e7c9d6836c724929ff8a365361e1a
24 files changed +374 -371
reftable/basics.c
+1 -1
@@ -260,7 +260,7 @@ int names_equal(const char **a, const char **b)
260 return a[i] == b[i];
261 }
262
263 -int common_prefix_size(struct strbuf *a, struct strbuf *b)
263 +int common_prefix_size(struct reftable_buf *a, struct reftable_buf *b)
264 {
265 int p = 0;
266 for (; p < a->len && p < b->len; p++) {
reftable/basics.h
+4 -3
@@ -57,7 +57,9 @@ int reftable_buf_setlen(struct reftable_buf *buf, size_t len);
57 int reftable_buf_cmp(const struct reftable_buf *a, const struct reftable_buf *b);
58
59 /*
60 - * Add the given bytes to the buffer. Returns 0 on success,
60 + * Append `len` bytes from `data` to the buffer. This function works with
61 + * arbitrary byte sequences, including ones that contain embedded NUL
62 + * characters. As such, we use `void *` as input type. Returns 0 on success,
63 * REFTABLE_OUT_OF_MEMORY_ERROR on allocation failure.
64 */
65 int reftable_buf_add(struct reftable_buf *buf, const void *data, size_t len);
@@ -144,8 +146,7 @@ char *reftable_strdup(const char *str);
146 #endif
147
148 /* Find the longest shared prefix size of `a` and `b` */
147 -struct strbuf;
148 -int common_prefix_size(struct strbuf *a, struct strbuf *b);
149 +int common_prefix_size(struct reftable_buf *a, struct reftable_buf *b);
150
151 int hash_size(uint32_t id);
152
reftable/block.c
+17 -17
@@ -38,7 +38,7 @@ int footer_size(int version)
38 }
39
40 static int block_writer_register_restart(struct block_writer *w, int n,
41 - int is_restart, struct strbuf *key)
41 + int is_restart, struct reftable_buf *key)
42 {
43 int rlen = w->restart_len;
44 if (rlen >= MAX_RESTARTS) {
@@ -59,8 +59,8 @@ static int block_writer_register_restart(struct block_writer *w, int n,
59
60 w->next += n;
61
62 - strbuf_reset(&w->last_key);
63 - strbuf_add(&w->last_key, key->buf, key->len);
62 + reftable_buf_reset(&w->last_key);
63 + reftable_buf_add(&w->last_key, key->buf, key->len);
64 w->entries++;
65 return 0;
66 }
@@ -98,8 +98,8 @@ uint8_t block_writer_type(struct block_writer *bw)
98 empty key. */
99 int block_writer_add(struct block_writer *w, struct reftable_record *rec)
100 {
101 - struct strbuf empty = STRBUF_INIT;
102 - struct strbuf last =
101 + struct reftable_buf empty = REFTABLE_BUF_INIT;
102 + struct reftable_buf last =
103 w->entries % w->restart_interval == 0 ? empty : w->last_key;
104 struct string_view out = {
105 .buf = w->buf + w->next,
@@ -109,7 +109,7 @@ int block_writer_add(struct block_writer *w, struct reftable_record *rec)
109 struct string_view start = out;
110
111 int is_restart = 0;
112 - struct strbuf key = STRBUF_INIT;
112 + struct reftable_buf key = REFTABLE_BUF_INIT;
113 int n = 0;
114 int err = -1;
115
@@ -133,7 +133,7 @@ int block_writer_add(struct block_writer *w, struct reftable_record *rec)
133 err = block_writer_register_restart(w, start.len - out.len, is_restart,
134 &key);
135 done:
136 - strbuf_release(&key);
136 + reftable_buf_release(&key);
137 return err;
138 }
139
@@ -325,7 +325,7 @@ uint8_t block_reader_type(const struct block_reader *r)
325 return r->block.data[r->header_off];
326 }
327
328 -int block_reader_first_key(const struct block_reader *br, struct strbuf *key)
328 +int block_reader_first_key(const struct block_reader *br, struct reftable_buf *key)
329 {
330 int off = br->header_off + 4, n;
331 struct string_view in = {
@@ -334,7 +334,7 @@ int block_reader_first_key(const struct block_reader *br, struct strbuf *key)
334 };
335 uint8_t extra = 0;
336
337 - strbuf_reset(key);
337 + reftable_buf_reset(key);
338
339 n = reftable_decode_key(key, &extra, in);
340 if (n < 0)
@@ -355,13 +355,13 @@ void block_iter_seek_start(struct block_iter *it, const struct block_reader *br)
355 it->block = br->block.data;
356 it->block_len = br->block_len;
357 it->hash_size = br->hash_size;
358 - strbuf_reset(&it->last_key);
358 + reftable_buf_reset(&it->last_key);
359 it->next_off = br->header_off + 4;
360 }
361
362 struct restart_needle_less_args {
363 int error;
364 - struct strbuf needle;
364 + struct reftable_buf needle;
365 const struct block_reader *reader;
366 };
367
@@ -433,7 +433,7 @@ int block_iter_next(struct block_iter *it, struct reftable_record *rec)
433
434 void block_iter_reset(struct block_iter *it)
435 {
436 - strbuf_reset(&it->last_key);
436 + reftable_buf_reset(&it->last_key);
437 it->next_off = 0;
438 it->block = NULL;
439 it->block_len = 0;
@@ -442,12 +442,12 @@ void block_iter_reset(struct block_iter *it)
442
443 void block_iter_close(struct block_iter *it)
444 {
445 - strbuf_release(&it->last_key);
446 - strbuf_release(&it->scratch);
445 + reftable_buf_release(&it->last_key);
446 + reftable_buf_release(&it->scratch);
447 }
448
449 int block_iter_seek_key(struct block_iter *it, const struct block_reader *br,
450 - struct strbuf *want)
450 + struct reftable_buf *want)
451 {
452 struct restart_needle_less_args args = {
453 .needle = *want,
@@ -537,7 +537,7 @@ int block_iter_seek_key(struct block_iter *it, const struct block_reader *br,
537 * with themselves.
538 */
539 reftable_record_key(&rec, &it->last_key);
540 - if (strbuf_cmp(&it->last_key, want) >= 0) {
540 + if (reftable_buf_cmp(&it->last_key, want) >= 0) {
541 it->next_off = prev_off;
542 goto done;
543 }
@@ -554,7 +554,7 @@ void block_writer_release(struct block_writer *bw)
554 REFTABLE_FREE_AND_NULL(bw->zstream);
555 REFTABLE_FREE_AND_NULL(bw->restarts);
556 REFTABLE_FREE_AND_NULL(bw->compressed);
557 - strbuf_release(&bw->last_key);
557 + reftable_buf_release(&bw->last_key);
558 /* the block is not owned. */
559 }
560
reftable/block.h
+7 -7
@@ -38,7 +38,7 @@ struct block_writer {
38 uint32_t restart_len;
39 uint32_t restart_cap;
40
41 - struct strbuf last_key;
41 + struct reftable_buf last_key;
42 int entries;
43 };
44
@@ -98,7 +98,7 @@ void block_reader_release(struct block_reader *br);
98 uint8_t block_reader_type(const struct block_reader *r);
99
100 /* Decodes the first key in the block */
101 -int block_reader_first_key(const struct block_reader *br, struct strbuf *key);
101 +int block_reader_first_key(const struct block_reader *br, struct reftable_buf *key);
102
103 /* Iterate over entries in a block */
104 struct block_iter {
@@ -109,13 +109,13 @@ struct block_iter {
109 int hash_size;
110
111 /* key for last entry we read. */
112 - struct strbuf last_key;
113 - struct strbuf scratch;
112 + struct reftable_buf last_key;
113 + struct reftable_buf scratch;
114 };
115
116 #define BLOCK_ITER_INIT { \
117 - .last_key = STRBUF_INIT, \
118 - .scratch = STRBUF_INIT, \
117 + .last_key = REFTABLE_BUF_INIT, \
118 + .scratch = REFTABLE_BUF_INIT, \
119 }
120
121 /* Position `it` at start of the block */
@@ -123,7 +123,7 @@ void block_iter_seek_start(struct block_iter *it, const struct block_reader *br)
123
124 /* Position `it` to the `want` key in the block */
125 int block_iter_seek_key(struct block_iter *it, const struct block_reader *br,
126 - struct strbuf *want);
126 + struct reftable_buf *want);
127
128 /* return < 0 for error, 0 for OK, > 0 for EOF. */
129 int block_iter_next(struct block_iter *it, struct reftable_record *rec);
reftable/blocksource.c
+3 -3
@@ -27,7 +27,7 @@ static void strbuf_close(void *b UNUSED)
27 static int strbuf_read_block(void *v, struct reftable_block *dest, uint64_t off,
28 uint32_t size)
29 {
30 - struct strbuf *b = v;
30 + struct reftable_buf *b = v;
31 assert(off + size <= b->len);
32 REFTABLE_CALLOC_ARRAY(dest->data, size);
33 if (!dest->data)
@@ -39,7 +39,7 @@ static int strbuf_read_block(void *v, struct reftable_block *dest, uint64_t off,
39
40 static uint64_t strbuf_size(void *b)
41 {
42 - return ((struct strbuf *)b)->len;
42 + return ((struct reftable_buf *)b)->len;
43 }
44
45 static struct reftable_block_source_vtable strbuf_vtable = {
@@ -50,7 +50,7 @@ static struct reftable_block_source_vtable strbuf_vtable = {
50 };
51
52 void block_source_from_strbuf(struct reftable_block_source *bs,
53 - struct strbuf *buf)
53 + struct reftable_buf *buf)
54 {
55 assert(!bs->ops);
56 bs->ops = &strbuf_vtable;
reftable/blocksource.h
+2 -1
@@ -12,9 +12,10 @@ https://developers.google.com/open-source/licenses/bsd
12 #include "system.h"
13
14 struct reftable_block_source;
15 +struct reftable_buf;
16
17 /* Create an in-memory block source for reading reftables */
18 void block_source_from_strbuf(struct reftable_block_source *bs,
18 - struct strbuf *buf);
19 + struct reftable_buf *buf);
20
21 #endif
reftable/iter.c
+3 -3
@@ -55,7 +55,7 @@ void iterator_set_empty(struct reftable_iterator *it)
55 static void filtering_ref_iterator_close(void *iter_arg)
56 {
57 struct filtering_ref_iterator *fri = iter_arg;
58 - strbuf_release(&fri->oid);
58 + reftable_buf_release(&fri->oid);
59 reftable_iterator_destroy(&fri->it);
60 }
61
@@ -115,7 +115,7 @@ static void indexed_table_ref_iter_close(void *p)
115 block_iter_close(&it->cur);
116 reftable_block_done(&it->block_reader.block);
117 reftable_free(it->offsets);
118 - strbuf_release(&it->oid);
118 + reftable_buf_release(&it->oid);
119 }
120
121 static int indexed_table_ref_iter_next_block(struct indexed_table_ref_iter *it)
@@ -197,7 +197,7 @@ int indexed_table_ref_iter_new(struct indexed_table_ref_iter **dest,
197
198 *itr = empty;
199 itr->r = r;
200 - strbuf_add(&itr->oid, oid, oid_len);
200 + reftable_buf_add(&itr->oid, oid, oid_len);
201
202 itr->offsets = offsets;
203 itr->offset_len = offset_len;
reftable/iter.h
+4 -4
@@ -44,12 +44,12 @@ void iterator_set_empty(struct reftable_iterator *it);
44
45 /* iterator that produces only ref records that point to `oid` */
46 struct filtering_ref_iterator {
47 - struct strbuf oid;
47 + struct reftable_buf oid;
48 struct reftable_iterator it;
49 };
50 #define FILTERING_REF_ITERATOR_INIT \
51 { \
52 - .oid = STRBUF_INIT \
52 + .oid = REFTABLE_BUF_INIT \
53 }
54
55 void iterator_from_filtering_ref_iterator(struct reftable_iterator *,
@@ -60,7 +60,7 @@ void iterator_from_filtering_ref_iterator(struct reftable_iterator *,
60 */
61 struct indexed_table_ref_iter {
62 struct reftable_reader *r;
63 - struct strbuf oid;
63 + struct reftable_buf oid;
64
65 /* mutable */
66 uint64_t *offsets;
@@ -75,7 +75,7 @@ struct indexed_table_ref_iter {
75
76 #define INDEXED_TABLE_REF_ITER_INIT { \
77 .cur = BLOCK_ITER_INIT, \
78 - .oid = STRBUF_INIT, \
78 + .oid = REFTABLE_BUF_INIT, \
79 }
80
81 void iterator_from_indexed_table_ref_iter(struct reftable_iterator *it,
reftable/reader.c
+8 -8
@@ -350,8 +350,8 @@ static int table_iter_seek_start(struct table_iter *ti, uint8_t typ, int index)
350 static int table_iter_seek_linear(struct table_iter *ti,
351 struct reftable_record *want)
352 {
353 - struct strbuf want_key = STRBUF_INIT;
354 - struct strbuf got_key = STRBUF_INIT;
353 + struct reftable_buf want_key = REFTABLE_BUF_INIT;
354 + struct reftable_buf got_key = REFTABLE_BUF_INIT;
355 struct reftable_record rec;
356 int err;
357
@@ -401,7 +401,7 @@ static int table_iter_seek_linear(struct table_iter *ti,
401 if (err < 0)
402 goto done;
403
404 - if (strbuf_cmp(&got_key, &want_key) > 0) {
404 + if (reftable_buf_cmp(&got_key, &want_key) > 0) {
405 table_iter_block_done(&next);
406 break;
407 }
@@ -422,8 +422,8 @@ static int table_iter_seek_linear(struct table_iter *ti,
422
423 done:
424 reftable_record_release(&rec);
425 - strbuf_release(&want_key);
426 - strbuf_release(&got_key);
425 + reftable_buf_release(&want_key);
426 + reftable_buf_release(&got_key);
427 return err;
428 }
429
@@ -431,11 +431,11 @@ static int table_iter_seek_indexed(struct table_iter *ti,
431 struct reftable_record *rec)
432 {
433 struct reftable_record want_index = {
434 - .type = BLOCK_TYPE_INDEX, .u.idx = { .last_key = STRBUF_INIT }
434 + .type = BLOCK_TYPE_INDEX, .u.idx = { .last_key = REFTABLE_BUF_INIT }
435 };
436 struct reftable_record index_result = {
437 .type = BLOCK_TYPE_INDEX,
438 - .u.idx = { .last_key = STRBUF_INIT },
438 + .u.idx = { .last_key = REFTABLE_BUF_INIT },
439 };
440 int err;
441
@@ -765,7 +765,7 @@ static int reftable_reader_refs_for_unindexed(struct reftable_reader *r,
765 }
766 *filter = empty;
767
768 - strbuf_add(&filter->oid, oid, oid_len);
768 + reftable_buf_add(&filter->oid, oid, oid_len);
769 iterator_from_table_iter(&filter->it, ti);
770
771 iterator_from_filtering_ref_iterator(it, filter);
reftable/record.c
+40 -40
@@ -98,7 +98,7 @@ const unsigned char *reftable_ref_record_val2(const struct reftable_ref_record *
98 }
99 }
100
101 -static int decode_string(struct strbuf *dest, struct string_view in)
101 +static int decode_string(struct reftable_buf *dest, struct string_view in)
102 {
103 int start_len = in.len;
104 uint64_t tsize = 0;
@@ -109,8 +109,8 @@ static int decode_string(struct strbuf *dest, struct string_view in)
109 if (in.len < tsize)
110 return -1;
111
112 - strbuf_reset(dest);
113 - strbuf_add(dest, in.buf, tsize);
112 + reftable_buf_reset(dest);
113 + reftable_buf_add(dest, in.buf, tsize);
114 string_view_consume(&in, tsize);
115
116 return start_len - in.len;
@@ -133,7 +133,7 @@ static int encode_string(const char *str, struct string_view s)
133 }
134
135 int reftable_encode_key(int *restart, struct string_view dest,
136 - struct strbuf prev_key, struct strbuf key,
136 + struct reftable_buf prev_key, struct reftable_buf key,
137 uint8_t extra)
138 {
139 struct string_view start = dest;
@@ -183,7 +183,7 @@ int reftable_decode_keylen(struct string_view in,
183 return start_len - in.len;
184 }
185
186 -int reftable_decode_key(struct strbuf *last_key, uint8_t *extra,
186 +int reftable_decode_key(struct reftable_buf *last_key, uint8_t *extra,
187 struct string_view in)
188 {
189 int start_len = in.len;
@@ -200,19 +200,19 @@ int reftable_decode_key(struct strbuf *last_key, uint8_t *extra,
200 prefix_len > last_key->len)
201 return -1;
202
203 - strbuf_setlen(last_key, prefix_len);
204 - strbuf_add(last_key, in.buf, suffix_len);
203 + reftable_buf_setlen(last_key, prefix_len);
204 + reftable_buf_add(last_key, in.buf, suffix_len);
205 string_view_consume(&in, suffix_len);
206
207 return start_len - in.len;
208 }
209
210 -static void reftable_ref_record_key(const void *r, struct strbuf *dest)
210 +static void reftable_ref_record_key(const void *r, struct reftable_buf *dest)
211 {
212 const struct reftable_ref_record *rec =
213 (const struct reftable_ref_record *)r;
214 - strbuf_reset(dest);
215 - strbuf_addstr(dest, rec->refname);
214 + reftable_buf_reset(dest);
215 + reftable_buf_addstr(dest, rec->refname);
216 }
217
218 static int reftable_ref_record_copy_from(void *rec, const void *src_rec,
@@ -350,9 +350,9 @@ static int reftable_ref_record_encode(const void *rec, struct string_view s,
350 return start.len - s.len;
351 }
352
353 -static int reftable_ref_record_decode(void *rec, struct strbuf key,
353 +static int reftable_ref_record_decode(void *rec, struct reftable_buf key,
354 uint8_t val_type, struct string_view in,
355 - int hash_size, struct strbuf *scratch)
355 + int hash_size, struct reftable_buf *scratch)
356 {
357 struct reftable_ref_record *r = rec;
358 struct string_view start = in;
@@ -415,7 +415,7 @@ static int reftable_ref_record_decode(void *rec, struct strbuf key,
415 goto done;
416 }
417 string_view_consume(&in, n);
418 - r->value.symref = strbuf_detach(scratch, NULL);
418 + r->value.symref = reftable_buf_detach(scratch);
419 } break;
420
421 case REFTABLE_REF_DELETION:
@@ -465,12 +465,12 @@ static struct reftable_record_vtable reftable_ref_record_vtable = {
465 .cmp = &reftable_ref_record_cmp_void,
466 };
467
468 -static void reftable_obj_record_key(const void *r, struct strbuf *dest)
468 +static void reftable_obj_record_key(const void *r, struct reftable_buf *dest)
469 {
470 const struct reftable_obj_record *rec =
471 (const struct reftable_obj_record *)r;
472 - strbuf_reset(dest);
473 - strbuf_add(dest, rec->hash_prefix, rec->hash_prefix_len);
472 + reftable_buf_reset(dest);
473 + reftable_buf_add(dest, rec->hash_prefix, rec->hash_prefix_len);
474 }
475
476 static void reftable_obj_record_release(void *rec)
@@ -547,10 +547,10 @@ static int reftable_obj_record_encode(const void *rec, struct string_view s,
547 return start.len - s.len;
548 }
549
550 -static int reftable_obj_record_decode(void *rec, struct strbuf key,
550 +static int reftable_obj_record_decode(void *rec, struct reftable_buf key,
551 uint8_t val_type, struct string_view in,
552 int hash_size UNUSED,
553 - struct strbuf *scratch UNUSED)
553 + struct reftable_buf *scratch UNUSED)
554 {
555 struct string_view start = in;
556 struct reftable_obj_record *r = rec;
@@ -664,19 +664,19 @@ static struct reftable_record_vtable reftable_obj_record_vtable = {
664 .cmp = &reftable_obj_record_cmp_void,
665 };
666
667 -static void reftable_log_record_key(const void *r, struct strbuf *dest)
667 +static void reftable_log_record_key(const void *r, struct reftable_buf *dest)
668 {
669 const struct reftable_log_record *rec =
670 (const struct reftable_log_record *)r;
671 int len = strlen(rec->refname);
672 uint8_t i64[8];
673 uint64_t ts = 0;
674 - strbuf_reset(dest);
675 - strbuf_add(dest, (uint8_t *)rec->refname, len + 1);
674 + reftable_buf_reset(dest);
675 + reftable_buf_add(dest, (uint8_t *)rec->refname, len + 1);
676
677 ts = (~ts) - rec->update_index;
678 put_be64(&i64[0], ts);
679 - strbuf_add(dest, i64, sizeof(i64));
679 + reftable_buf_add(dest, i64, sizeof(i64));
680 }
681
682 static int reftable_log_record_copy_from(void *rec, const void *src_rec,
@@ -807,9 +807,9 @@ static int reftable_log_record_encode(const void *rec, struct string_view s,
807 return start.len - s.len;
808 }
809
810 -static int reftable_log_record_decode(void *rec, struct strbuf key,
810 +static int reftable_log_record_decode(void *rec, struct reftable_buf key,
811 uint8_t val_type, struct string_view in,
812 - int hash_size, struct strbuf *scratch)
812 + int hash_size, struct reftable_buf *scratch)
813 {
814 struct string_view start = in;
815 struct reftable_log_record *r = rec;
@@ -1027,11 +1027,11 @@ static struct reftable_record_vtable reftable_log_record_vtable = {
1027 .cmp = &reftable_log_record_cmp_void,
1028 };
1029
1030 -static void reftable_index_record_key(const void *r, struct strbuf *dest)
1030 +static void reftable_index_record_key(const void *r, struct reftable_buf *dest)
1031 {
1032 const struct reftable_index_record *rec = r;
1033 - strbuf_reset(dest);
1034 - strbuf_add(dest, rec->last_key.buf, rec->last_key.len);
1033 + reftable_buf_reset(dest);
1034 + reftable_buf_add(dest, rec->last_key.buf, rec->last_key.len);
1035 }
1036
1037 static int reftable_index_record_copy_from(void *rec, const void *src_rec,
@@ -1040,8 +1040,8 @@ static int reftable_index_record_copy_from(void *rec, const void *src_rec,
1040 struct reftable_index_record *dst = rec;
1041 const struct reftable_index_record *src = src_rec;
1042
1043 - strbuf_reset(&dst->last_key);
1044 - strbuf_add(&dst->last_key, src->last_key.buf, src->last_key.len);
1043 + reftable_buf_reset(&dst->last_key);
1044 + reftable_buf_add(&dst->last_key, src->last_key.buf, src->last_key.len);
1045 dst->offset = src->offset;
1046
1047 return 0;
@@ -1050,7 +1050,7 @@ static int reftable_index_record_copy_from(void *rec, const void *src_rec,
1050 static void reftable_index_record_release(void *rec)
1051 {
1052 struct reftable_index_record *idx = rec;
1053 - strbuf_release(&idx->last_key);
1053 + reftable_buf_release(&idx->last_key);
1054 }
1055
1056 static uint8_t reftable_index_record_val_type(const void *rec UNUSED)
@@ -1074,18 +1074,18 @@ static int reftable_index_record_encode(const void *rec, struct string_view out,
1074 return start.len - out.len;
1075 }
1076
1077 -static int reftable_index_record_decode(void *rec, struct strbuf key,
1077 +static int reftable_index_record_decode(void *rec, struct reftable_buf key,
1078 uint8_t val_type UNUSED,
1079 struct string_view in,
1080 int hash_size UNUSED,
1081 - struct strbuf *scratch UNUSED)
1081 + struct reftable_buf *scratch UNUSED)
1082 {
1083 struct string_view start = in;
1084 struct reftable_index_record *r = rec;
1085 int n = 0;
1086
1087 - strbuf_reset(&r->last_key);
1088 - strbuf_add(&r->last_key, key.buf, key.len);
1087 + reftable_buf_reset(&r->last_key);
1088 + reftable_buf_add(&r->last_key, key.buf, key.len);
1089
1090 n = get_var_int(&r->offset, &in);
1091 if (n < 0)
@@ -1101,14 +1101,14 @@ static int reftable_index_record_equal(const void *a, const void *b,
1101 struct reftable_index_record *ia = (struct reftable_index_record *) a;
1102 struct reftable_index_record *ib = (struct reftable_index_record *) b;
1103
1104 - return ia->offset == ib->offset && !strbuf_cmp(&ia->last_key, &ib->last_key);
1104 + return ia->offset == ib->offset && !reftable_buf_cmp(&ia->last_key, &ib->last_key);
1105 }
1106
1107 static int reftable_index_record_cmp(const void *_a, const void *_b)
1108 {
1109 const struct reftable_index_record *a = _a;
1110 const struct reftable_index_record *b = _b;
1111 - return strbuf_cmp(&a->last_key, &b->last_key);
1111 + return reftable_buf_cmp(&a->last_key, &b->last_key);
1112 }
1113
1114 static struct reftable_record_vtable reftable_index_record_vtable = {
@@ -1124,7 +1124,7 @@ static struct reftable_record_vtable reftable_index_record_vtable = {
1124 .cmp = &reftable_index_record_cmp,
1125 };
1126
1127 -void reftable_record_key(struct reftable_record *rec, struct strbuf *dest)
1127 +void reftable_record_key(struct reftable_record *rec, struct reftable_buf *dest)
1128 {
1129 reftable_record_vtable(rec)->key(reftable_record_data(rec), dest);
1130 }
@@ -1151,9 +1151,9 @@ uint8_t reftable_record_val_type(struct reftable_record *rec)
1151 return reftable_record_vtable(rec)->val_type(reftable_record_data(rec));
1152 }
1153
1154 -int reftable_record_decode(struct reftable_record *rec, struct strbuf key,
1154 +int reftable_record_decode(struct reftable_record *rec, struct reftable_buf key,
1155 uint8_t extra, struct string_view src, int hash_size,
1156 - struct strbuf *scratch)
1156 + struct reftable_buf *scratch)
1157 {
1158 return reftable_record_vtable(rec)->decode(reftable_record_data(rec),
1159 key, extra, src, hash_size,
@@ -1294,7 +1294,7 @@ void reftable_record_init(struct reftable_record *rec, uint8_t typ)
1294 case BLOCK_TYPE_OBJ:
1295 return;
1296 case BLOCK_TYPE_INDEX:
1297 - strbuf_init(&rec->u.idx.last_key, 0);
1297 + reftable_buf_init(&rec->u.idx.last_key);
1298 return;
1299 default:
1300 BUG("unhandled record type");
reftable/record.h
+11 -10
@@ -9,6 +9,7 @@ https://developers.google.com/open-source/licenses/bsd
9 #ifndef RECORD_H
10 #define RECORD_H
11
12 +#include "basics.h"
13 #include "system.h"
14
15 #include <stdint.h>
@@ -38,8 +39,8 @@ int put_var_int(struct string_view *dest, uint64_t val);
39
40 /* Methods for records. */
41 struct reftable_record_vtable {
41 - /* encode the key of to a uint8_t strbuf. */
42 - void (*key)(const void *rec, struct strbuf *dest);
42 + /* encode the key of to a uint8_t reftable_buf. */
43 + void (*key)(const void *rec, struct reftable_buf *dest);
44
45 /* The record type of ('r' for ref). */
46 uint8_t type;
@@ -54,9 +55,9 @@ struct reftable_record_vtable {
55 int (*encode)(const void *rec, struct string_view dest, int hash_size);
56
57 /* decode data from `src` into the record. */
57 - int (*decode)(void *rec, struct strbuf key, uint8_t extra,
58 + int (*decode)(void *rec, struct reftable_buf key, uint8_t extra,
59 struct string_view src, int hash_size,
59 - struct strbuf *scratch);
60 + struct reftable_buf *scratch);
61
62 /* deallocate and null the record. */
63 void (*release)(void *rec);
@@ -83,7 +84,7 @@ int reftable_is_block_type(uint8_t typ);
84 /* Encode `key` into `dest`. Sets `is_restart` to indicate a restart. Returns
85 * number of bytes written. */
86 int reftable_encode_key(int *is_restart, struct string_view dest,
86 - struct strbuf prev_key, struct strbuf key,
87 + struct reftable_buf prev_key, struct reftable_buf key,
88 uint8_t extra);
89
90 /* Decode a record's key lengths. */
@@ -96,13 +97,13 @@ int reftable_decode_keylen(struct string_view in,
97 * Decode into `last_key` and `extra` from `in`. `last_key` is expected to
98 * contain the decoded key of the preceding record, if any.
99 */
99 -int reftable_decode_key(struct strbuf *last_key, uint8_t *extra,
100 +int reftable_decode_key(struct reftable_buf *last_key, uint8_t *extra,
101 struct string_view in);
102
103 /* reftable_index_record are used internally to speed up lookups. */
104 struct reftable_index_record {
105 uint64_t offset; /* Offset of block */
105 - struct strbuf last_key; /* Last key of the block. */
106 + struct reftable_buf last_key; /* Last key of the block. */
107 };
108
109 /* reftable_obj_record stores an object ID => ref mapping. */
@@ -136,15 +137,15 @@ void reftable_record_init(struct reftable_record *rec, uint8_t typ);
137 /* see struct record_vtable */
138 int reftable_record_cmp(struct reftable_record *a, struct reftable_record *b);
139 int reftable_record_equal(struct reftable_record *a, struct reftable_record *b, int hash_size);
139 -void reftable_record_key(struct reftable_record *rec, struct strbuf *dest);
140 +void reftable_record_key(struct reftable_record *rec, struct reftable_buf *dest);
141 int reftable_record_copy_from(struct reftable_record *rec,
142 struct reftable_record *src, int hash_size);
143 uint8_t reftable_record_val_type(struct reftable_record *rec);
144 int reftable_record_encode(struct reftable_record *rec, struct string_view dest,
145 int hash_size);
145 -int reftable_record_decode(struct reftable_record *rec, struct strbuf key,
146 +int reftable_record_decode(struct reftable_record *rec, struct reftable_buf key,
147 uint8_t extra, struct string_view src,
147 - int hash_size, struct strbuf *scratch);
148 + int hash_size, struct reftable_buf *scratch);
149 int reftable_record_is_deletion(struct reftable_record *rec);
150
151 static inline uint8_t reftable_record_type(struct reftable_record *rec)
reftable/stack.c
+60 -60
@@ -31,13 +31,13 @@ static void reftable_addition_close(struct reftable_addition *add);
31 static int reftable_stack_reload_maybe_reuse(struct reftable_stack *st,
32 int reuse_open);
33
34 -static void stack_filename(struct strbuf *dest, struct reftable_stack *st,
34 +static void stack_filename(struct reftable_buf *dest, struct reftable_stack *st,
35 const char *name)
36 {
37 - strbuf_reset(dest);
38 - strbuf_addstr(dest, st->reftable_dir);
39 - strbuf_addstr(dest, "/");
40 - strbuf_addstr(dest, name);
37 + reftable_buf_reset(dest);
38 + reftable_buf_addstr(dest, st->reftable_dir);
39 + reftable_buf_addstr(dest, "/");
40 + reftable_buf_addstr(dest, name);
41 }
42
43 static ssize_t reftable_fd_write(void *arg, const void *data, size_t sz)
@@ -56,7 +56,7 @@ static int reftable_fd_flush(void *arg)
56 int reftable_new_stack(struct reftable_stack **dest, const char *dir,
57 const struct reftable_write_options *_opts)
58 {
59 - struct strbuf list_file_name = STRBUF_INIT;
59 + struct reftable_buf list_file_name = REFTABLE_BUF_INIT;
60 struct reftable_write_options opts = { 0 };
61 struct reftable_stack *p;
62 int err;
@@ -74,11 +74,11 @@ int reftable_new_stack(struct reftable_stack **dest, const char *dir,
74
75 *dest = NULL;
76
77 - strbuf_reset(&list_file_name);
78 - strbuf_addstr(&list_file_name, dir);
79 - strbuf_addstr(&list_file_name, "/tables.list");
77 + reftable_buf_reset(&list_file_name);
78 + reftable_buf_addstr(&list_file_name, dir);
79 + reftable_buf_addstr(&list_file_name, "/tables.list");
80
81 - p->list_file = strbuf_detach(&list_file_name, NULL);
81 + p->list_file = reftable_buf_detach(&list_file_name);
82 p->list_fd = -1;
83 p->opts = opts;
84 p->reftable_dir = reftable_strdup(dir);
@@ -208,10 +208,10 @@ void reftable_stack_destroy(struct reftable_stack *st)
208
209 if (st->readers) {
210 int i = 0;
211 - struct strbuf filename = STRBUF_INIT;
211 + struct reftable_buf filename = REFTABLE_BUF_INIT;
212 for (i = 0; i < st->readers_len; i++) {
213 const char *name = reader_name(st->readers[i]);
214 - strbuf_reset(&filename);
214 + reftable_buf_reset(&filename);
215 if (names && !has_name(names, name)) {
216 stack_filename(&filename, st, name);
217 }
@@ -222,7 +222,7 @@ void reftable_stack_destroy(struct reftable_stack *st)
222 unlink(filename.buf);
223 }
224 }
225 - strbuf_release(&filename);
225 + reftable_buf_release(&filename);
226 st->readers_len = 0;
227 REFTABLE_FREE_AND_NULL(st->readers);
228 }
@@ -260,7 +260,7 @@ static int reftable_stack_reload_once(struct reftable_stack *st,
260 size_t reused_len = 0, reused_alloc = 0, names_len;
261 size_t new_readers_len = 0;
262 struct reftable_merged_table *new_merged = NULL;
263 - struct strbuf table_path = STRBUF_INIT;
263 + struct reftable_buf table_path = REFTABLE_BUF_INIT;
264 int err = 0;
265 size_t i;
266
@@ -374,7 +374,7 @@ done:
374 reftable_free(new_readers);
375 reftable_free(reused);
376 reftable_free(cur);
377 - strbuf_release(&table_path);
377 + reftable_buf_release(&table_path);
378 return err;
379 }
380
@@ -623,14 +623,14 @@ int reftable_stack_add(struct reftable_stack *st,
623 return 0;
624 }
625
626 -static void format_name(struct strbuf *dest, uint64_t min, uint64_t max)
626 +static void format_name(struct reftable_buf *dest, uint64_t min, uint64_t max)
627 {
628 char buf[100];
629 uint32_t rnd = (uint32_t)git_rand();
630 snprintf(buf, sizeof(buf), "0x%012" PRIx64 "-0x%012" PRIx64 "-%08x",
631 min, max, rnd);
632 - strbuf_reset(dest);
633 - strbuf_addstr(dest, buf);
632 + reftable_buf_reset(dest);
633 + reftable_buf_addstr(dest, buf);
634 }
635
636 struct reftable_addition {
@@ -648,7 +648,7 @@ static int reftable_stack_init_addition(struct reftable_addition *add,
648 struct reftable_stack *st,
649 unsigned int flags)
650 {
651 - struct strbuf lock_file_name = STRBUF_INIT;
651 + struct reftable_buf lock_file_name = REFTABLE_BUF_INIT;
652 int err;
653
654 add->stack = st;
@@ -690,13 +690,13 @@ static int reftable_stack_init_addition(struct reftable_addition *add,
690 done:
691 if (err)
692 reftable_addition_close(add);
693 - strbuf_release(&lock_file_name);
693 + reftable_buf_release(&lock_file_name);
694 return err;
695 }
696
697 static void reftable_addition_close(struct reftable_addition *add)
698 {
699 - struct strbuf nm = STRBUF_INIT;
699 + struct reftable_buf nm = REFTABLE_BUF_INIT;
700 size_t i;
701
702 for (i = 0; i < add->new_tables_len; i++) {
@@ -711,7 +711,7 @@ static void reftable_addition_close(struct reftable_addition *add)
711 add->new_tables_cap = 0;
712
713 rollback_lock_file(&add->tables_list_lock);
714 - strbuf_release(&nm);
714 + reftable_buf_release(&nm);
715 }
716
717 void reftable_addition_destroy(struct reftable_addition *add)
@@ -725,7 +725,7 @@ void reftable_addition_destroy(struct reftable_addition *add)
725
726 int reftable_addition_commit(struct reftable_addition *add)
727 {
728 - struct strbuf table_list = STRBUF_INIT;
728 + struct reftable_buf table_list = REFTABLE_BUF_INIT;
729 int lock_file_fd = get_lock_file_fd(&add->tables_list_lock);
730 int err = 0;
731 size_t i;
@@ -734,16 +734,16 @@ int reftable_addition_commit(struct reftable_addition *add)
734 goto done;
735
736 for (i = 0; i < add->stack->merged->readers_len; i++) {
737 - strbuf_addstr(&table_list, add->stack->readers[i]->name);
738 - strbuf_addstr(&table_list, "\n");
737 + reftable_buf_addstr(&table_list, add->stack->readers[i]->name);
738 + reftable_buf_addstr(&table_list, "\n");
739 }
740 for (i = 0; i < add->new_tables_len; i++) {
741 - strbuf_addstr(&table_list, add->new_tables[i]);
742 - strbuf_addstr(&table_list, "\n");
741 + reftable_buf_addstr(&table_list, add->new_tables[i]);
742 + reftable_buf_addstr(&table_list, "\n");
743 }
744
745 err = write_in_full(lock_file_fd, table_list.buf, table_list.len);
746 - strbuf_release(&table_list);
746 + reftable_buf_release(&table_list);
747 if (err < 0) {
748 err = REFTABLE_IO_ERROR;
749 goto done;
@@ -837,19 +837,19 @@ int reftable_addition_add(struct reftable_addition *add,
837 void *arg),
838 void *arg)
839 {
840 - struct strbuf temp_tab_file_name = STRBUF_INIT;
841 - struct strbuf tab_file_name = STRBUF_INIT;
842 - struct strbuf next_name = STRBUF_INIT;
840 + struct reftable_buf temp_tab_file_name = REFTABLE_BUF_INIT;
841 + struct reftable_buf tab_file_name = REFTABLE_BUF_INIT;
842 + struct reftable_buf next_name = REFTABLE_BUF_INIT;
843 struct reftable_writer *wr = NULL;
844 struct tempfile *tab_file = NULL;
845 int err = 0;
846 int tab_fd;
847
848 - strbuf_reset(&next_name);
848 + reftable_buf_reset(&next_name);
849 format_name(&next_name, add->next_update_index, add->next_update_index);
850
851 stack_filename(&temp_tab_file_name, add->stack, next_name.buf);
852 - strbuf_addstr(&temp_tab_file_name, ".temp.XXXXXX");
852 + reftable_buf_addstr(&temp_tab_file_name, ".temp.XXXXXX");
853
854 tab_file = mks_tempfile(temp_tab_file_name.buf);
855 if (!tab_file) {
@@ -894,7 +894,7 @@ int reftable_addition_add(struct reftable_addition *add,
894 }
895
896 format_name(&next_name, wr->min_update_index, wr->max_update_index);
897 - strbuf_addstr(&next_name, ".ref");
897 + reftable_buf_addstr(&next_name, ".ref");
898 stack_filename(&tab_file_name, add->stack, next_name.buf);
899
900 /*
@@ -913,13 +913,13 @@ int reftable_addition_add(struct reftable_addition *add,
913 err = REFTABLE_OUT_OF_MEMORY_ERROR;
914 goto done;
915 }
916 - add->new_tables[add->new_tables_len++] = strbuf_detach(&next_name, NULL);
916 + add->new_tables[add->new_tables_len++] = reftable_buf_detach(&next_name);
917
918 done:
919 delete_tempfile(&tab_file);
920 - strbuf_release(&temp_tab_file_name);
921 - strbuf_release(&tab_file_name);
922 - strbuf_release(&next_name);
920 + reftable_buf_release(&temp_tab_file_name);
921 + reftable_buf_release(&tab_file_name);
922 + reftable_buf_release(&next_name);
923 reftable_writer_free(wr);
924 return err;
925 }
@@ -938,8 +938,8 @@ static int stack_compact_locked(struct reftable_stack *st,
938 struct reftable_log_expiry_config *config,
939 struct tempfile **tab_file_out)
940 {
941 - struct strbuf next_name = STRBUF_INIT;
942 - struct strbuf tab_file_path = STRBUF_INIT;
941 + struct reftable_buf next_name = REFTABLE_BUF_INIT;
942 + struct reftable_buf tab_file_path = REFTABLE_BUF_INIT;
943 struct reftable_writer *wr = NULL;
944 struct tempfile *tab_file;
945 int tab_fd, err = 0;
@@ -948,7 +948,7 @@ static int stack_compact_locked(struct reftable_stack *st,
948 reftable_reader_min_update_index(st->readers[first]),
949 reftable_reader_max_update_index(st->readers[last]));
950 stack_filename(&tab_file_path, st, next_name.buf);
951 - strbuf_addstr(&tab_file_path, ".temp.XXXXXX");
951 + reftable_buf_addstr(&tab_file_path, ".temp.XXXXXX");
952
953 tab_file = mks_tempfile(tab_file_path.buf);
954 if (!tab_file) {
@@ -986,8 +986,8 @@ static int stack_compact_locked(struct reftable_stack *st,
986 done:
987 delete_tempfile(&tab_file);
988 reftable_writer_free(wr);
989 - strbuf_release(&next_name);
990 - strbuf_release(&tab_file_path);
989 + reftable_buf_release(&next_name);
990 + reftable_buf_release(&tab_file_path);
991 return err;
992 }
993
@@ -1111,10 +1111,10 @@ static int stack_compact_range(struct reftable_stack *st,
1111 struct reftable_log_expiry_config *expiry,
1112 unsigned int flags)
1113 {
1114 - struct strbuf tables_list_buf = STRBUF_INIT;
1115 - struct strbuf new_table_name = STRBUF_INIT;
1116 - struct strbuf new_table_path = STRBUF_INIT;
1117 - struct strbuf table_name = STRBUF_INIT;
1114 + struct reftable_buf tables_list_buf = REFTABLE_BUF_INIT;
1115 + struct reftable_buf new_table_name = REFTABLE_BUF_INIT;
1116 + struct reftable_buf new_table_path = REFTABLE_BUF_INIT;
1117 + struct reftable_buf table_name = REFTABLE_BUF_INIT;
1118 struct lock_file tables_list_lock = LOCK_INIT;
1119 struct lock_file *table_locks = NULL;
1120 struct tempfile *new_table = NULL;
@@ -1372,7 +1372,7 @@ static int stack_compact_range(struct reftable_stack *st,
1372 if (!is_empty_table) {
1373 format_name(&new_table_name, st->readers[first]->min_update_index,
1374 st->readers[last]->max_update_index);
1375 - strbuf_addstr(&new_table_name, ".ref");
1375 + reftable_buf_addstr(&new_table_name, ".ref");
1376 stack_filename(&new_table_path, st, new_table_name.buf);
1377
1378 err = rename_tempfile(&new_table, new_table_path.buf);
@@ -1388,16 +1388,16 @@ static int stack_compact_range(struct reftable_stack *st,
1388 * simply skip writing it.
1389 */
1390 for (i = 0; i < first_to_replace; i++) {
1391 - strbuf_addstr(&tables_list_buf, names[i]);
1392 - strbuf_addstr(&tables_list_buf, "\n");
1391 + reftable_buf_addstr(&tables_list_buf, names[i]);
1392 + reftable_buf_addstr(&tables_list_buf, "\n");
1393 }
1394 if (!is_empty_table) {
1395 - strbuf_addstr(&tables_list_buf, new_table_name.buf);
1396 - strbuf_addstr(&tables_list_buf, "\n");
1395 + reftable_buf_addstr(&tables_list_buf, new_table_name.buf);
1396 + reftable_buf_addstr(&tables_list_buf, "\n");
1397 }
1398 for (i = last_to_replace + 1; names[i]; i++) {
1399 - strbuf_addstr(&tables_list_buf, names[i]);
1400 - strbuf_addstr(&tables_list_buf, "\n");
1399 + reftable_buf_addstr(&tables_list_buf, names[i]);
1400 + reftable_buf_addstr(&tables_list_buf, "\n");
1401 }
1402
1403 err = write_in_full(get_lock_file_fd(&tables_list_lock),
@@ -1449,10 +1449,10 @@ done:
1449 reftable_free(table_locks);
1450
1451 delete_tempfile(&new_table);
1452 - strbuf_release(&new_table_name);
1453 - strbuf_release(&new_table_path);
1454 - strbuf_release(&tables_list_buf);
1455 - strbuf_release(&table_name);
1452 + reftable_buf_release(&new_table_name);
1453 + reftable_buf_release(&new_table_path);
1454 + reftable_buf_release(&tables_list_buf);
1455 + reftable_buf_release(&table_name);
1456 free_names(names);
1457
1458 if (err == REFTABLE_LOCK_ERROR)
@@ -1666,7 +1666,7 @@ static void remove_maybe_stale_table(struct reftable_stack *st, uint64_t max,
1666 uint64_t update_idx = 0;
1667 struct reftable_block_source src = { NULL };
1668 struct reftable_reader *rd = NULL;
1669 - struct strbuf table_path = STRBUF_INIT;
1669 + struct reftable_buf table_path = REFTABLE_BUF_INIT;
1670 stack_filename(&table_path, st, name);
1671
1672 err = reftable_block_source_from_file(&src, table_path.buf);
@@ -1684,7 +1684,7 @@ static void remove_maybe_stale_table(struct reftable_stack *st, uint64_t max,
1684 unlink(table_path.buf);
1685 }
1686 done:
1687 - strbuf_release(&table_path);
1687 + reftable_buf_release(&table_path);
1688 }
1689
1690 static int reftable_stack_clean_locked(struct reftable_stack *st)
reftable/system.h
-1
@@ -13,7 +13,6 @@ https://developers.google.com/open-source/licenses/bsd
13
14 #include "git-compat-util.h"
15 #include "lockfile.h"
16 -#include "strbuf.h"
16 #include "tempfile.h"
17 #include "hash.h" /* hash ID, sizes.*/
18 #include "dir.h" /* remove_dir_recursively, for tests.*/
reftable/writer.c
+33 -33
@@ -115,7 +115,7 @@ static int writer_reinit_block_writer(struct reftable_writer *w, uint8_t typ)
115 if (w->next == 0)
116 block_start = header_size(writer_version(w));
117
118 - strbuf_reset(&w->last_key);
118 + reftable_buf_reset(&w->last_key);
119 ret = block_writer_init(&w->block_writer_data, typ, w->block,
120 w->opts.block_size, block_start,
121 hash_size(w->opts.hash_id));
@@ -146,8 +146,8 @@ int reftable_writer_new(struct reftable_writer **out,
146 if (opts.block_size >= (1 << 24))
147 BUG("configured block size exceeds 16MB");
148
149 - strbuf_init(&wp->block_writer_data.last_key, 0);
150 - strbuf_init(&wp->last_key, 0);
149 + reftable_buf_init(&wp->block_writer_data.last_key);
150 + reftable_buf_init(&wp->last_key);
151 REFTABLE_CALLOC_ARRAY(wp->block, opts.block_size);
152 if (!wp->block) {
153 reftable_free(wp);
@@ -179,7 +179,7 @@ static void writer_release(struct reftable_writer *w)
179 block_writer_release(&w->block_writer_data);
180 w->block_writer = NULL;
181 writer_clear_index(w);
182 - strbuf_release(&w->last_key);
182 + reftable_buf_release(&w->last_key);
183 }
184 }
185
@@ -190,7 +190,7 @@ void reftable_writer_free(struct reftable_writer *w)
190 }
191
192 struct obj_index_tree_node {
193 - struct strbuf hash;
193 + struct reftable_buf hash;
194 uint64_t *offsets;
195 size_t offset_len;
196 size_t offset_cap;
@@ -198,16 +198,16 @@ struct obj_index_tree_node {
198
199 #define OBJ_INDEX_TREE_NODE_INIT \
200 { \
201 - .hash = STRBUF_INIT \
201 + .hash = REFTABLE_BUF_INIT \
202 }
203
204 static int obj_index_tree_node_compare(const void *a, const void *b)
205 {
206 - return strbuf_cmp(&((const struct obj_index_tree_node *)a)->hash,
206 + return reftable_buf_cmp(&((const struct obj_index_tree_node *)a)->hash,
207 &((const struct obj_index_tree_node *)b)->hash);
208 }
209
210 -static int writer_index_hash(struct reftable_writer *w, struct strbuf *hash)
210 +static int writer_index_hash(struct reftable_writer *w, struct reftable_buf *hash)
211 {
212 uint64_t off = w->next;
213 struct obj_index_tree_node want = { .hash = *hash };
@@ -224,8 +224,8 @@ static int writer_index_hash(struct reftable_writer *w, struct strbuf *hash)
224
225 *key = empty;
226
227 - strbuf_reset(&key->hash);
228 - strbuf_add(&key->hash, hash->buf, hash->len);
227 + reftable_buf_reset(&key->hash);
228 + reftable_buf_add(&key->hash, hash->buf, hash->len);
229 tree_insert(&w->obj_index_tree, key,
230 &obj_index_tree_node_compare);
231 } else {
@@ -246,17 +246,17 @@ static int writer_index_hash(struct reftable_writer *w, struct strbuf *hash)
246 static int writer_add_record(struct reftable_writer *w,
247 struct reftable_record *rec)
248 {
249 - struct strbuf key = STRBUF_INIT;
249 + struct reftable_buf key = REFTABLE_BUF_INIT;
250 int err;
251
252 reftable_record_key(rec, &key);
253 - if (strbuf_cmp(&w->last_key, &key) >= 0) {
253 + if (reftable_buf_cmp(&w->last_key, &key) >= 0) {
254 err = REFTABLE_API_ERROR;
255 goto done;
256 }
257
258 - strbuf_reset(&w->last_key);
259 - strbuf_add(&w->last_key, key.buf, key.len);
258 + reftable_buf_reset(&w->last_key);
259 + reftable_buf_add(&w->last_key, key.buf, key.len);
260 if (!w->block_writer) {
261 err = writer_reinit_block_writer(w, reftable_record_type(rec));
262 if (err < 0)
@@ -303,7 +303,7 @@ static int writer_add_record(struct reftable_writer *w,
303 }
304
305 done:
306 - strbuf_release(&key);
306 + reftable_buf_release(&key);
307 return err;
308 }
309
@@ -316,7 +316,7 @@ int reftable_writer_add_ref(struct reftable_writer *w,
316 .ref = *ref
317 },
318 };
319 - struct strbuf buf = STRBUF_INIT;
319 + struct reftable_buf buf = REFTABLE_BUF_INIT;
320 int err;
321
322 if (!ref->refname ||
@@ -331,7 +331,7 @@ int reftable_writer_add_ref(struct reftable_writer *w,
331 goto out;
332
333 if (!w->opts.skip_index_objects && reftable_ref_record_val1(ref)) {
334 - strbuf_add(&buf, (char *)reftable_ref_record_val1(ref),
334 + reftable_buf_add(&buf, (char *)reftable_ref_record_val1(ref),
335 hash_size(w->opts.hash_id));
336
337 err = writer_index_hash(w, &buf);
@@ -340,8 +340,8 @@ int reftable_writer_add_ref(struct reftable_writer *w,
340 }
341
342 if (!w->opts.skip_index_objects && reftable_ref_record_val2(ref)) {
343 - strbuf_reset(&buf);
344 - strbuf_add(&buf, reftable_ref_record_val2(ref),
343 + reftable_buf_reset(&buf);
344 + reftable_buf_add(&buf, reftable_ref_record_val2(ref),
345 hash_size(w->opts.hash_id));
346
347 err = writer_index_hash(w, &buf);
@@ -352,7 +352,7 @@ int reftable_writer_add_ref(struct reftable_writer *w,
352 err = 0;
353
354 out:
355 - strbuf_release(&buf);
355 + reftable_buf_release(&buf);
356 return err;
357 }
358
@@ -393,7 +393,7 @@ int reftable_writer_add_log(struct reftable_writer *w,
393 struct reftable_log_record *log)
394 {
395 char *input_log_message = NULL;
396 - struct strbuf cleaned_message = STRBUF_INIT;
396 + struct reftable_buf cleaned_message = REFTABLE_BUF_INIT;
397 int err = 0;
398
399 if (log->value_type == REFTABLE_LOG_DELETION)
@@ -404,24 +404,24 @@ int reftable_writer_add_log(struct reftable_writer *w,
404
405 input_log_message = log->value.update.message;
406 if (!w->opts.exact_log_message && log->value.update.message) {
407 - strbuf_addstr(&cleaned_message, log->value.update.message);
407 + reftable_buf_addstr(&cleaned_message, log->value.update.message);
408 while (cleaned_message.len &&
409 cleaned_message.buf[cleaned_message.len - 1] == '\n')
410 - strbuf_setlen(&cleaned_message,
410 + reftable_buf_setlen(&cleaned_message,
411 cleaned_message.len - 1);
412 if (strchr(cleaned_message.buf, '\n')) {
413 /* multiple lines not allowed. */
414 err = REFTABLE_API_ERROR;
415 goto done;
416 }
417 - strbuf_addstr(&cleaned_message, "\n");
417 + reftable_buf_addstr(&cleaned_message, "\n");
418 log->value.update.message = cleaned_message.buf;
419 }
420
421 err = reftable_writer_add_log_verbatim(w, log);
422 log->value.update.message = input_log_message;
423 done:
424 - strbuf_release(&cleaned_message);
424 + reftable_buf_release(&cleaned_message);
425 return err;
426 }
427
@@ -504,7 +504,7 @@ static int writer_finish_section(struct reftable_writer *w)
504 return err;
505
506 for (i = 0; i < idx_len; i++)
507 - strbuf_release(&idx[i].last_key);
507 + reftable_buf_release(&idx[i].last_key);
508 reftable_free(idx);
509 }
510
@@ -521,13 +521,13 @@ static int writer_finish_section(struct reftable_writer *w)
521 bstats->max_index_level = max_level;
522
523 /* Reinit lastKey, as the next section can start with any key. */
524 - strbuf_reset(&w->last_key);
524 + reftable_buf_reset(&w->last_key);
525
526 return 0;
527 }
528
529 struct common_prefix_arg {
530 - struct strbuf *last;
530 + struct reftable_buf *last;
531 int max;
532 };
533
@@ -594,7 +594,7 @@ static void object_record_free(void *void_arg UNUSED, void *key)
594 struct obj_index_tree_node *entry = key;
595
596 REFTABLE_FREE_AND_NULL(entry->offsets);
597 - strbuf_release(&entry->hash);
597 + reftable_buf_release(&entry->hash);
598 reftable_free(entry);
599 }
600
@@ -708,7 +708,7 @@ done:
708 static void writer_clear_index(struct reftable_writer *w)
709 {
710 for (size_t i = 0; w->index && i < w->index_len; i++)
711 - strbuf_release(&w->index[i].last_key);
711 + reftable_buf_release(&w->index[i].last_key);
712 REFTABLE_FREE_AND_NULL(w->index);
713 w->index_len = 0;
714 w->index_cap = 0;
@@ -717,7 +717,7 @@ static void writer_clear_index(struct reftable_writer *w)
717 static int writer_flush_nonempty_block(struct reftable_writer *w)
718 {
719 struct reftable_index_record index_record = {
720 - .last_key = STRBUF_INIT,
720 + .last_key = REFTABLE_BUF_INIT,
721 };
722 uint8_t typ = block_writer_type(w->block_writer);
723 struct reftable_block_stats *bstats;
@@ -777,8 +777,8 @@ static int writer_flush_nonempty_block(struct reftable_writer *w)
777 return REFTABLE_OUT_OF_MEMORY_ERROR;
778
779 index_record.offset = w->next;
780 - strbuf_reset(&index_record.last_key);
781 - strbuf_add(&index_record.last_key, w->block_writer->last_key.buf,
780 + reftable_buf_reset(&index_record.last_key);
781 + reftable_buf_add(&index_record.last_key, w->block_writer->last_key.buf,
782 w->block_writer->last_key.len);
783 w->index[w->index_len] = index_record;
784 w->index_len++;
reftable/writer.h
+1 -1
@@ -19,7 +19,7 @@ struct reftable_writer {
19 int (*flush)(void *);
20 void *write_arg;
21 int pending_padding;
22 - struct strbuf last_key;
22 + struct reftable_buf last_key;
23
24 /* offset of next block to write. */
25 uint64_t next;
t/unit-tests/lib-reftable.c
+2 -2
@@ -19,7 +19,7 @@ static int strbuf_writer_flush(void *arg UNUSED)
19 return 0;
20 }
21
22 -struct reftable_writer *t_reftable_strbuf_writer(struct strbuf *buf,
22 +struct reftable_writer *t_reftable_strbuf_writer(struct reftable_buf *buf,
23 struct reftable_write_options *opts)
24 {
25 struct reftable_writer *writer;
@@ -29,7 +29,7 @@ struct reftable_writer *t_reftable_strbuf_writer(struct strbuf *buf,
29 return writer;
30 }
31
32 -void t_reftable_write_to_buf(struct strbuf *buf,
32 +void t_reftable_write_to_buf(struct reftable_buf *buf,
33 struct reftable_ref_record *refs,
34 size_t nrefs,
35 struct reftable_log_record *logs,
t/unit-tests/lib-reftable.h
+4 -3
@@ -2,15 +2,16 @@
2 #define LIB_REFTABLE_H
3
4 #include "git-compat-util.h"
5 -#include "strbuf.h"
5 #include "reftable/reftable-writer.h"
6
7 +struct reftable_buf;
8 +
9 void t_reftable_set_hash(uint8_t *p, int i, uint32_t id);
10
10 -struct reftable_writer *t_reftable_strbuf_writer(struct strbuf *buf,
11 +struct reftable_writer *t_reftable_strbuf_writer(struct reftable_buf *buf,
12 struct reftable_write_options *opts);
13
13 -void t_reftable_write_to_buf(struct strbuf *buf,
14 +void t_reftable_write_to_buf(struct reftable_buf *buf,
15 struct reftable_ref_record *refs,
16 size_t nrecords,
17 struct reftable_log_record *logs,
t/unit-tests/t-reftable-basics.c
+8 -8
@@ -99,8 +99,8 @@ int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
99 }
100
101 if_test ("common_prefix_size works") {
102 - struct strbuf a = STRBUF_INIT;
103 - struct strbuf b = STRBUF_INIT;
102 + struct reftable_buf a = REFTABLE_BUF_INIT;
103 + struct reftable_buf b = REFTABLE_BUF_INIT;
104 struct {
105 const char *a, *b;
106 int want;
@@ -113,14 +113,14 @@ int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
113 };
114
115 for (size_t i = 0; i < ARRAY_SIZE(cases); i++) {
116 - strbuf_addstr(&a, cases[i].a);
117 - strbuf_addstr(&b, cases[i].b);
116 + reftable_buf_addstr(&a, cases[i].a);
117 + reftable_buf_addstr(&b, cases[i].b);
118 check_int(common_prefix_size(&a, &b), ==, cases[i].want);
119 - strbuf_reset(&a);
120 - strbuf_reset(&b);
119 + reftable_buf_reset(&a);
120 + reftable_buf_reset(&b);
121 }
122 - strbuf_release(&a);
123 - strbuf_release(&b);
122 + reftable_buf_release(&a);
123 + reftable_buf_release(&b);
124 }
125
126 if_test ("put_be24 and get_be24 work") {
t/unit-tests/t-reftable-block.c
+21 -21
@@ -20,7 +20,7 @@ static void t_ref_block_read_write(void)
20 const size_t block_size = 1024;
21 struct reftable_block block = { 0 };
22 struct block_writer bw = {
23 - .last_key = STRBUF_INIT,
23 + .last_key = REFTABLE_BUF_INIT,
24 };
25 struct reftable_record rec = {
26 .type = BLOCK_TYPE_REF,
@@ -29,7 +29,7 @@ static void t_ref_block_read_write(void)
29 int ret;
30 struct block_reader br = { 0 };
31 struct block_iter it = BLOCK_ITER_INIT;
32 - struct strbuf want = STRBUF_INIT, buf = STRBUF_INIT;
32 + struct reftable_buf want = REFTABLE_BUF_INIT, buf = REFTABLE_BUF_INIT;
33
34 REFTABLE_CALLOC_ARRAY(block.data, block_size);
35 check(block.data != NULL);
@@ -100,8 +100,8 @@ static void t_ref_block_read_write(void)
100 block_iter_close(&it);
101 reftable_record_release(&rec);
102 reftable_block_done(&br.block);
103 - strbuf_release(&want);
104 - strbuf_release(&buf);
103 + reftable_buf_release(&want);
104 + reftable_buf_release(&buf);
105 for (i = 0; i < N; i++)
106 reftable_record_release(&recs[i]);
107 }
@@ -114,7 +114,7 @@ static void t_log_block_read_write(void)
114 const size_t block_size = 2048;
115 struct reftable_block block = { 0 };
116 struct block_writer bw = {
117 - .last_key = STRBUF_INIT,
117 + .last_key = REFTABLE_BUF_INIT,
118 };
119 struct reftable_record rec = {
120 .type = BLOCK_TYPE_LOG,
@@ -123,7 +123,7 @@ static void t_log_block_read_write(void)
123 int ret;
124 struct block_reader br = { 0 };
125 struct block_iter it = BLOCK_ITER_INIT;
126 - struct strbuf want = STRBUF_INIT, buf = STRBUF_INIT;
126 + struct reftable_buf want = REFTABLE_BUF_INIT, buf = REFTABLE_BUF_INIT;
127
128 REFTABLE_CALLOC_ARRAY(block.data, block_size);
129 check(block.data != NULL);
@@ -166,8 +166,8 @@ static void t_log_block_read_write(void)
166
167 for (i = 0; i < N; i++) {
168 block_iter_reset(&it);
169 - strbuf_reset(&want);
170 - strbuf_addstr(&want, recs[i].u.log.refname);
169 + reftable_buf_reset(&want);
170 + reftable_buf_addstr(&want, recs[i].u.log.refname);
171
172 ret = block_iter_seek_key(&it, &br, &want);
173 check_int(ret, ==, 0);
@@ -190,8 +190,8 @@ static void t_log_block_read_write(void)
190 block_iter_close(&it);
191 reftable_record_release(&rec);
192 reftable_block_done(&br.block);
193 - strbuf_release(&want);
194 - strbuf_release(&buf);
193 + reftable_buf_release(&want);
194 + reftable_buf_release(&buf);
195 for (i = 0; i < N; i++)
196 reftable_record_release(&recs[i]);
197 }
@@ -204,7 +204,7 @@ static void t_obj_block_read_write(void)
204 const size_t block_size = 1024;
205 struct reftable_block block = { 0 };
206 struct block_writer bw = {
207 - .last_key = STRBUF_INIT,
207 + .last_key = REFTABLE_BUF_INIT,
208 };
209 struct reftable_record rec = {
210 .type = BLOCK_TYPE_OBJ,
@@ -213,7 +213,7 @@ static void t_obj_block_read_write(void)
213 int ret;
214 struct block_reader br = { 0 };
215 struct block_iter it = BLOCK_ITER_INIT;
216 - struct strbuf want = STRBUF_INIT, buf = STRBUF_INIT;
216 + struct reftable_buf want = REFTABLE_BUF_INIT, buf = REFTABLE_BUF_INIT;
217
218 REFTABLE_CALLOC_ARRAY(block.data, block_size);
219 check(block.data != NULL);
@@ -273,8 +273,8 @@ static void t_obj_block_read_write(void)
273 block_iter_close(&it);
274 reftable_record_release(&rec);
275 reftable_block_done(&br.block);
276 - strbuf_release(&want);
277 - strbuf_release(&buf);
276 + reftable_buf_release(&want);
277 + reftable_buf_release(&buf);
278 for (i = 0; i < N; i++)
279 reftable_record_release(&recs[i]);
280 }
@@ -287,17 +287,17 @@ static void t_index_block_read_write(void)
287 const size_t block_size = 1024;
288 struct reftable_block block = { 0 };
289 struct block_writer bw = {
290 - .last_key = STRBUF_INIT,
290 + .last_key = REFTABLE_BUF_INIT,
291 };
292 struct reftable_record rec = {
293 .type = BLOCK_TYPE_INDEX,
294 - .u.idx.last_key = STRBUF_INIT,
294 + .u.idx.last_key = REFTABLE_BUF_INIT,
295 };
296 size_t i = 0;
297 int ret;
298 struct block_reader br = { 0 };
299 struct block_iter it = BLOCK_ITER_INIT;
300 - struct strbuf want = STRBUF_INIT, buf = STRBUF_INIT;
300 + struct reftable_buf want = REFTABLE_BUF_INIT, buf = REFTABLE_BUF_INIT;
301
302 REFTABLE_CALLOC_ARRAY(block.data, block_size);
303 check(block.data != NULL);
@@ -312,9 +312,9 @@ static void t_index_block_read_write(void)
312
313 snprintf(buf, sizeof(buf), "branch%02"PRIuMAX, (uintmax_t)i);
314
315 - strbuf_init(&recs[i].u.idx.last_key, 9);
315 + reftable_buf_init(&recs[i].u.idx.last_key);
316 recs[i].type = BLOCK_TYPE_INDEX;
317 - strbuf_addstr(&recs[i].u.idx.last_key, buf);
317 + reftable_buf_addstr(&recs[i].u.idx.last_key, buf);
318 recs[i].u.idx.offset = i;
319
320 ret = block_writer_add(&bw, &recs[i]);
@@ -365,8 +365,8 @@ static void t_index_block_read_write(void)
365 block_iter_close(&it);
366 reftable_record_release(&rec);
367 reftable_block_done(&br.block);
368 - strbuf_release(&want);
369 - strbuf_release(&buf);
368 + reftable_buf_release(&want);
369 + reftable_buf_release(&buf);
370 for (i = 0; i < N; i++)
371 reftable_record_release(&recs[i]);
372 }
t/unit-tests/t-reftable-merged.c
+13 -13
@@ -20,7 +20,7 @@ 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,
23 - struct strbuf *buf, const size_t n)
23 + struct reftable_buf *buf, const size_t n)
24 {
25 struct reftable_merged_table *mt = NULL;
26 struct reftable_write_options opts = {
@@ -75,7 +75,7 @@ static void t_merged_single_record(void)
75
76 struct reftable_ref_record *refs[] = { r1, r2, r3 };
77 size_t sizes[] = { ARRAY_SIZE(r1), ARRAY_SIZE(r2), ARRAY_SIZE(r3) };
78 - struct strbuf bufs[3] = { STRBUF_INIT, STRBUF_INIT, STRBUF_INIT };
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;
81 struct reftable_merged_table *mt =
@@ -97,7 +97,7 @@ static void t_merged_single_record(void)
97 readers_destroy(readers, 3);
98 reftable_merged_table_free(mt);
99 for (size_t i = 0; i < ARRAY_SIZE(bufs); i++)
100 - strbuf_release(&bufs[i]);
100 + reftable_buf_release(&bufs[i]);
101 reftable_free(bs);
102 }
103
@@ -152,7 +152,7 @@ static void t_merged_refs(void)
152
153 struct reftable_ref_record *refs[] = { r1, r2, r3 };
154 size_t sizes[3] = { ARRAY_SIZE(r1), ARRAY_SIZE(r2), ARRAY_SIZE(r3) };
155 - struct strbuf bufs[3] = { STRBUF_INIT, STRBUF_INIT, STRBUF_INIT };
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;
158 struct reftable_merged_table *mt =
@@ -192,7 +192,7 @@ static void t_merged_refs(void)
192 reftable_free(out);
193
194 for (i = 0; i < 3; i++)
195 - strbuf_release(&bufs[i]);
195 + reftable_buf_release(&bufs[i]);
196 readers_destroy(readers, 3);
197 reftable_merged_table_free(mt);
198 reftable_free(bs);
@@ -234,8 +234,8 @@ static void t_merged_seek_multiple_times(void)
234 size_t sizes[] = {
235 ARRAY_SIZE(r1), ARRAY_SIZE(r2),
236 };
237 - struct strbuf bufs[] = {
238 - STRBUF_INIT, STRBUF_INIT,
237 + struct reftable_buf bufs[] = {
238 + REFTABLE_BUF_INIT, REFTABLE_BUF_INIT,
239 };
240 struct reftable_block_source *sources = NULL;
241 struct reftable_reader **readers = NULL;
@@ -265,7 +265,7 @@ static void t_merged_seek_multiple_times(void)
265 }
266
267 for (size_t i = 0; i < ARRAY_SIZE(bufs); i++)
268 - strbuf_release(&bufs[i]);
268 + reftable_buf_release(&bufs[i]);
269 readers_destroy(readers, ARRAY_SIZE(refs));
270 reftable_ref_record_release(&rec);
271 reftable_iterator_destroy(&it);
@@ -277,7 +277,7 @@ static struct reftable_merged_table *
277 merged_table_from_log_records(struct reftable_log_record **logs,
278 struct reftable_block_source **source,
279 struct reftable_reader ***readers, const size_t *sizes,
280 - struct strbuf *buf, const size_t n)
280 + struct reftable_buf *buf, const size_t n)
281 {
282 struct reftable_merged_table *mt = NULL;
283 struct reftable_write_options opts = {
@@ -361,7 +361,7 @@ static void t_merged_logs(void)
361
362 struct reftable_log_record *logs[] = { r1, r2, r3 };
363 size_t sizes[3] = { ARRAY_SIZE(r1), ARRAY_SIZE(r2), ARRAY_SIZE(r3) };
364 - struct strbuf bufs[3] = { STRBUF_INIT, STRBUF_INIT, STRBUF_INIT };
364 + struct reftable_buf bufs[3] = { REFTABLE_BUF_INIT, REFTABLE_BUF_INIT, REFTABLE_BUF_INIT };
365 struct reftable_block_source *bs = NULL;
366 struct reftable_reader **readers = NULL;
367 struct reftable_merged_table *mt = merged_table_from_log_records(
@@ -412,7 +412,7 @@ static void t_merged_logs(void)
412 reftable_free(out);
413
414 for (i = 0; i < 3; i++)
415 - strbuf_release(&bufs[i]);
415 + reftable_buf_release(&bufs[i]);
416 readers_destroy(readers, 3);
417 reftable_merged_table_free(mt);
418 reftable_free(bs);
@@ -421,7 +421,7 @@ static void t_merged_logs(void)
421 static void t_default_write_opts(void)
422 {
423 struct reftable_write_options opts = { 0 };
424 - struct strbuf buf = STRBUF_INIT;
424 + struct reftable_buf buf = REFTABLE_BUF_INIT;
425 struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
426 struct reftable_ref_record rec = {
427 .refname = (char *) "master",
@@ -457,7 +457,7 @@ static void t_default_write_opts(void)
457
458 reftable_reader_decref(rd);
459 reftable_merged_table_free(merged);
460 - strbuf_release(&buf);
460 + reftable_buf_release(&buf);
461 }
462
463
t/unit-tests/t-reftable-reader.c
+4 -4
@@ -16,7 +16,7 @@ static int t_reader_seek_once(void)
16 struct reftable_ref_record ref = { 0 };
17 struct reftable_iterator it = { 0 };
18 struct reftable_reader *reader;
19 - struct strbuf buf = STRBUF_INIT;
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);
@@ -40,7 +40,7 @@ static int t_reader_seek_once(void)
40 reftable_ref_record_release(&ref);
41 reftable_iterator_destroy(&it);
42 reftable_reader_decref(reader);
43 - strbuf_release(&buf);
43 + reftable_buf_release(&buf);
44 return 0;
45 }
46
@@ -57,7 +57,7 @@ static int t_reader_reseek(void)
57 struct reftable_ref_record ref = { 0 };
58 struct reftable_iterator it = { 0 };
59 struct reftable_reader *reader;
60 - struct strbuf buf = STRBUF_INIT;
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);
@@ -84,7 +84,7 @@ static int t_reader_reseek(void)
84 reftable_ref_record_release(&ref);
85 reftable_iterator_destroy(&it);
86 reftable_reader_decref(reader);
87 - strbuf_release(&buf);
87 + reftable_buf_release(&buf);
88 return 0;
89 }
90
t/unit-tests/t-reftable-readwrite.c
+46 -46
@@ -18,12 +18,12 @@ static const int update_index = 5;
18
19 static void t_buffer(void)
20 {
21 - struct strbuf buf = STRBUF_INIT;
21 + struct reftable_buf buf = REFTABLE_BUF_INIT;
22 struct reftable_block_source source = { 0 };
23 struct reftable_block out = { 0 };
24 int n;
25 uint8_t in[] = "hello";
26 - strbuf_add(&buf, in, sizeof(in));
26 + reftable_buf_add(&buf, in, sizeof(in));
27 block_source_from_strbuf(&source, &buf);
28 check_int(block_source_size(&source), ==, 6);
29 n = block_source_read_block(&source, &out, 0, sizeof(in));
@@ -37,10 +37,10 @@ static void t_buffer(void)
37
38 reftable_block_done(&out);
39 block_source_close(&source);
40 - strbuf_release(&buf);
40 + reftable_buf_release(&buf);
41 }
42
43 -static void write_table(char ***names, struct strbuf *buf, int N,
43 +static void write_table(char ***names, struct reftable_buf *buf, int N,
44 int block_size, uint32_t hash_id)
45 {
46 struct reftable_write_options opts = {
@@ -82,7 +82,7 @@ static void write_table(char ***names, struct strbuf *buf, int N,
82
83 static void t_log_buffer_size(void)
84 {
85 - struct strbuf buf = STRBUF_INIT;
85 + struct reftable_buf buf = REFTABLE_BUF_INIT;
86 struct reftable_write_options opts = {
87 .block_size = 4096,
88 };
@@ -114,12 +114,12 @@ static void t_log_buffer_size(void)
114 err = reftable_writer_close(w);
115 check(!err);
116 reftable_writer_free(w);
117 - strbuf_release(&buf);
117 + reftable_buf_release(&buf);
118 }
119
120 static void t_log_overflow(void)
121 {
122 - struct strbuf buf = STRBUF_INIT;
122 + struct reftable_buf buf = REFTABLE_BUF_INIT;
123 char msg[256] = { 0 };
124 struct reftable_write_options opts = {
125 .block_size = ARRAY_SIZE(msg),
@@ -148,7 +148,7 @@ static void t_log_overflow(void)
148 err = reftable_writer_add_log(w, &log);
149 check_int(err, ==, REFTABLE_ENTRY_TOO_BIG_ERROR);
150 reftable_writer_free(w);
151 - strbuf_release(&buf);
151 + reftable_buf_release(&buf);
152 }
153
154 static void t_log_write_read(void)
@@ -161,7 +161,7 @@ static void t_log_write_read(void)
161 struct reftable_iterator it = { 0 };
162 struct reftable_reader *reader;
163 struct reftable_block_source source = { 0 };
164 - struct strbuf buf = STRBUF_INIT;
164 + struct reftable_buf buf = REFTABLE_BUF_INIT;
165 struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
166 const struct reftable_stats *stats = NULL;
167 int N = 2, err, i, n;
@@ -247,7 +247,7 @@ static void t_log_write_read(void)
247 reftable_iterator_destroy(&it);
248
249 /* cleanup. */
250 - strbuf_release(&buf);
250 + reftable_buf_release(&buf);
251 free_names(names);
252 reftable_reader_decref(reader);
253 }
@@ -260,7 +260,7 @@ static void t_log_zlib_corruption(void)
260 struct reftable_iterator it = { 0 };
261 struct reftable_reader *reader;
262 struct reftable_block_source source = { 0 };
263 - struct strbuf buf = STRBUF_INIT;
263 + struct reftable_buf buf = REFTABLE_BUF_INIT;
264 struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
265 const struct reftable_stats *stats = NULL;
266 char message[100] = { 0 };
@@ -312,13 +312,13 @@ static void t_log_zlib_corruption(void)
312
313 /* cleanup. */
314 reftable_reader_decref(reader);
315 - strbuf_release(&buf);
315 + reftable_buf_release(&buf);
316 }
317
318 static void t_table_read_write_sequential(void)
319 {
320 char **names;
321 - struct strbuf buf = STRBUF_INIT;
321 + struct reftable_buf buf = REFTABLE_BUF_INIT;
322 int N = 50;
323 struct reftable_iterator it = { 0 };
324 struct reftable_block_source source = { 0 };
@@ -352,25 +352,25 @@ static void t_table_read_write_sequential(void)
352
353 reftable_iterator_destroy(&it);
354 reftable_reader_decref(reader);
355 - strbuf_release(&buf);
355 + reftable_buf_release(&buf);
356 free_names(names);
357 }
358
359 static void t_table_write_small_table(void)
360 {
361 char **names;
362 - struct strbuf buf = STRBUF_INIT;
362 + struct reftable_buf buf = REFTABLE_BUF_INIT;
363 int N = 1;
364 write_table(&names, &buf, N, 4096, GIT_SHA1_FORMAT_ID);
365 check_int(buf.len, <, 200);
366 - strbuf_release(&buf);
366 + reftable_buf_release(&buf);
367 free_names(names);
368 }
369
370 static void t_table_read_api(void)
371 {
372 char **names;
373 - struct strbuf buf = STRBUF_INIT;
373 + struct reftable_buf buf = REFTABLE_BUF_INIT;
374 int N = 50;
375 struct reftable_reader *reader;
376 struct reftable_block_source source = { 0 };
@@ -393,17 +393,17 @@ static void t_table_read_api(void)
393 err = reftable_iterator_next_log(&it, &log);
394 check_int(err, ==, REFTABLE_API_ERROR);
395
396 - strbuf_release(&buf);
396 + reftable_buf_release(&buf);
397 free_names(names);
398 reftable_iterator_destroy(&it);
399 reftable_reader_decref(reader);
400 - strbuf_release(&buf);
400 + reftable_buf_release(&buf);
401 }
402
403 static void t_table_read_write_seek(int index, int hash_id)
404 {
405 char **names;
406 - struct strbuf buf = STRBUF_INIT;
406 + struct reftable_buf buf = REFTABLE_BUF_INIT;
407 int N = 50;
408 struct reftable_reader *reader;
409 struct reftable_block_source source = { 0 };
@@ -411,7 +411,7 @@ static void t_table_read_write_seek(int index, int hash_id)
411 int i = 0;
412
413 struct reftable_iterator it = { 0 };
414 - struct strbuf pastLast = STRBUF_INIT;
414 + struct reftable_buf pastLast = REFTABLE_BUF_INIT;
415 struct reftable_ref_record ref = { 0 };
416
417 write_table(&names, &buf, N, 256, hash_id);
@@ -443,8 +443,8 @@ static void t_table_read_write_seek(int index, int hash_id)
443 reftable_iterator_destroy(&it);
444 }
445
446 - strbuf_addstr(&pastLast, names[N - 1]);
447 - strbuf_addstr(&pastLast, "/");
446 + reftable_buf_addstr(&pastLast, names[N - 1]);
447 + reftable_buf_addstr(&pastLast, "/");
448
449 err = reftable_reader_init_ref_iterator(reader, &it);
450 check(!err);
@@ -457,10 +457,10 @@ static void t_table_read_write_seek(int index, int hash_id)
457 check_int(err, >, 0);
458 }
459
460 - strbuf_release(&pastLast);
460 + reftable_buf_release(&pastLast);
461 reftable_iterator_destroy(&it);
462
463 - strbuf_release(&buf);
463 + reftable_buf_release(&buf);
464 free_names(names);
465 reftable_reader_decref(reader);
466 }
@@ -492,7 +492,7 @@ static void t_table_refs_for(int indexed)
492 struct reftable_ref_record ref = { 0 };
493 struct reftable_reader *reader;
494 struct reftable_block_source source = { 0 };
495 - struct strbuf buf = STRBUF_INIT;
495 + struct reftable_buf buf = REFTABLE_BUF_INIT;
496 struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
497 struct reftable_iterator it = { 0 };
498 int N = 50, n, j, err, i;
@@ -565,7 +565,7 @@ static void t_table_refs_for(int indexed)
565 }
566 check_int(j, ==, want_names_len);
567
568 - strbuf_release(&buf);
568 + reftable_buf_release(&buf);
569 free_names(want_names);
570 reftable_iterator_destroy(&it);
571 reftable_reader_decref(reader);
@@ -584,7 +584,7 @@ static void t_table_refs_for_obj_index(void)
584 static void t_write_empty_table(void)
585 {
586 struct reftable_write_options opts = { 0 };
587 - struct strbuf buf = STRBUF_INIT;
587 + struct reftable_buf buf = REFTABLE_BUF_INIT;
588 struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
589 struct reftable_block_source source = { 0 };
590 struct reftable_reader *rd = NULL;
@@ -615,7 +615,7 @@ static void t_write_empty_table(void)
615
616 reftable_iterator_destroy(&it);
617 reftable_reader_decref(rd);
618 - strbuf_release(&buf);
618 + reftable_buf_release(&buf);
619 }
620
621 static void t_write_object_id_min_length(void)
@@ -623,7 +623,7 @@ static void t_write_object_id_min_length(void)
623 struct reftable_write_options opts = {
624 .block_size = 75,
625 };
626 - struct strbuf buf = STRBUF_INIT;
626 + struct reftable_buf buf = REFTABLE_BUF_INIT;
627 struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
628 struct reftable_ref_record ref = {
629 .update_index = 1,
@@ -649,7 +649,7 @@ static void t_write_object_id_min_length(void)
649 check(!err);
650 check_int(reftable_writer_stats(w)->object_id_len, ==, 2);
651 reftable_writer_free(w);
652 - strbuf_release(&buf);
652 + reftable_buf_release(&buf);
653 }
654
655 static void t_write_object_id_length(void)
@@ -657,7 +657,7 @@ static void t_write_object_id_length(void)
657 struct reftable_write_options opts = {
658 .block_size = 75,
659 };
660 - struct strbuf buf = STRBUF_INIT;
660 + struct reftable_buf buf = REFTABLE_BUF_INIT;
661 struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
662 struct reftable_ref_record ref = {
663 .update_index = 1,
@@ -684,13 +684,13 @@ static void t_write_object_id_length(void)
684 check(!err);
685 check_int(reftable_writer_stats(w)->object_id_len, ==, 16);
686 reftable_writer_free(w);
687 - strbuf_release(&buf);
687 + reftable_buf_release(&buf);
688 }
689
690 static void t_write_empty_key(void)
691 {
692 struct reftable_write_options opts = { 0 };
693 - struct strbuf buf = STRBUF_INIT;
693 + struct reftable_buf buf = REFTABLE_BUF_INIT;
694 struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
695 struct reftable_ref_record ref = {
696 .refname = (char *) "",
@@ -706,13 +706,13 @@ static void t_write_empty_key(void)
706 err = reftable_writer_close(w);
707 check_int(err, ==, REFTABLE_EMPTY_TABLE_ERROR);
708 reftable_writer_free(w);
709 - strbuf_release(&buf);
709 + reftable_buf_release(&buf);
710 }
711
712 static void t_write_key_order(void)
713 {
714 struct reftable_write_options opts = { 0 };
715 - struct strbuf buf = STRBUF_INIT;
715 + struct reftable_buf buf = REFTABLE_BUF_INIT;
716 struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
717 struct reftable_ref_record refs[2] = {
718 {
@@ -745,7 +745,7 @@ static void t_write_key_order(void)
745
746 reftable_writer_close(w);
747 reftable_writer_free(w);
748 - strbuf_release(&buf);
748 + reftable_buf_release(&buf);
749 }
750
751 static void t_write_multiple_indices(void)
@@ -753,7 +753,7 @@ static void t_write_multiple_indices(void)
753 struct reftable_write_options opts = {
754 .block_size = 100,
755 };
756 - struct strbuf writer_buf = STRBUF_INIT;
756 + struct reftable_buf writer_buf = REFTABLE_BUF_INIT;
757 struct reftable_block_source source = { 0 };
758 struct reftable_iterator it = { 0 };
759 const struct reftable_stats *stats;
@@ -822,7 +822,7 @@ static void t_write_multiple_indices(void)
822 reftable_iterator_destroy(&it);
823 reftable_writer_free(writer);
824 reftable_reader_decref(reader);
825 - strbuf_release(&writer_buf);
825 + reftable_buf_release(&writer_buf);
826 }
827
828 static void t_write_multi_level_index(void)
@@ -830,7 +830,7 @@ static void t_write_multi_level_index(void)
830 struct reftable_write_options opts = {
831 .block_size = 100,
832 };
833 - struct strbuf writer_buf = STRBUF_INIT, buf = STRBUF_INIT;
833 + struct reftable_buf writer_buf = REFTABLE_BUF_INIT, buf = REFTABLE_BUF_INIT;
834 struct reftable_block_source source = { 0 };
835 struct reftable_iterator it = { 0 };
836 const struct reftable_stats *stats;
@@ -878,13 +878,13 @@ static void t_write_multi_level_index(void)
878 reftable_iterator_destroy(&it);
879 reftable_writer_free(writer);
880 reftable_reader_decref(reader);
881 - strbuf_release(&writer_buf);
882 - strbuf_release(&buf);
881 + reftable_buf_release(&writer_buf);
882 + reftable_buf_release(&buf);
883 }
884
885 static void t_corrupt_table_empty(void)
886 {
887 - struct strbuf buf = STRBUF_INIT;
887 + struct reftable_buf buf = REFTABLE_BUF_INIT;
888 struct reftable_block_source source = { 0 };
889 struct reftable_reader *reader;
890 int err;
@@ -897,17 +897,17 @@ static void t_corrupt_table_empty(void)
897 static void t_corrupt_table(void)
898 {
899 uint8_t zeros[1024] = { 0 };
900 - struct strbuf buf = STRBUF_INIT;
900 + struct reftable_buf buf = REFTABLE_BUF_INIT;
901 struct reftable_block_source source = { 0 };
902 struct reftable_reader *reader;
903 int err;
904 - strbuf_add(&buf, zeros, sizeof(zeros));
904 + reftable_buf_add(&buf, zeros, sizeof(zeros));
905
906 block_source_from_strbuf(&source, &buf);
907 err = reftable_reader_new(&reader, &source, "file.log");
908 check_int(err, ==, REFTABLE_FORMAT_ERROR);
909
910 - strbuf_release(&buf);
910 + reftable_buf_release(&buf);
911 }
912
913 int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
t/unit-tests/t-reftable-record.c
+37 -37
@@ -116,7 +116,7 @@ static void t_reftable_ref_record_compare_name(void)
116
117 static void t_reftable_ref_record_roundtrip(void)
118 {
119 - struct strbuf scratch = STRBUF_INIT;
119 + struct reftable_buf scratch = REFTABLE_BUF_INIT;
120
121 for (int i = REFTABLE_REF_DELETION; i < REFTABLE_NR_REF_VALUETYPES; i++) {
122 struct reftable_record in = {
@@ -124,7 +124,7 @@ static void t_reftable_ref_record_roundtrip(void)
124 .u.ref.value_type = i,
125 };
126 struct reftable_record out = { .type = BLOCK_TYPE_REF };
127 - struct strbuf key = STRBUF_INIT;
127 + struct reftable_buf key = REFTABLE_BUF_INIT;
128 uint8_t buffer[1024] = { 0 };
129 struct string_view dest = {
130 .buf = buffer,
@@ -166,11 +166,11 @@ static void t_reftable_ref_record_roundtrip(void)
166 GIT_SHA1_RAWSZ));
167 reftable_record_release(&in);
168
169 - strbuf_release(&key);
169 + reftable_buf_release(&key);
170 reftable_record_release(&out);
171 }
172
173 - strbuf_release(&scratch);
173 + reftable_buf_release(&scratch);
174 }
175
176 static void t_reftable_log_record_comparison(void)
@@ -262,7 +262,7 @@ static void t_reftable_log_record_roundtrip(void)
262 .value_type = REFTABLE_LOG_UPDATE,
263 }
264 };
265 - struct strbuf scratch = STRBUF_INIT;
265 + struct reftable_buf scratch = REFTABLE_BUF_INIT;
266 set_hash(in[0].value.update.new_hash, 1);
267 set_hash(in[0].value.update.old_hash, 2);
268 set_hash(in[2].value.update.new_hash, 3);
@@ -274,7 +274,7 @@ static void t_reftable_log_record_roundtrip(void)
274
275 for (size_t i = 0; i < ARRAY_SIZE(in); i++) {
276 struct reftable_record rec = { .type = BLOCK_TYPE_LOG };
277 - struct strbuf key = STRBUF_INIT;
277 + struct reftable_buf key = REFTABLE_BUF_INIT;
278 uint8_t buffer[1024] = { 0 };
279 struct string_view dest = {
280 .buf = buffer,
@@ -313,11 +313,11 @@ static void t_reftable_log_record_roundtrip(void)
313 check(reftable_log_record_equal(&in[i], &out.u.log,
314 GIT_SHA1_RAWSZ));
315 reftable_log_record_release(&in[i]);
316 - strbuf_release(&key);
316 + reftable_buf_release(&key);
317 reftable_record_release(&out);
318 }
319
320 - strbuf_release(&scratch);
320 + reftable_buf_release(&scratch);
321 }
322
323 static void t_key_roundtrip(void)
@@ -327,30 +327,30 @@ static void t_key_roundtrip(void)
327 .buf = buffer,
328 .len = sizeof(buffer),
329 };
330 - struct strbuf last_key = STRBUF_INIT;
331 - struct strbuf key = STRBUF_INIT;
332 - struct strbuf roundtrip = STRBUF_INIT;
330 + struct reftable_buf last_key = REFTABLE_BUF_INIT;
331 + struct reftable_buf key = REFTABLE_BUF_INIT;
332 + struct reftable_buf roundtrip = REFTABLE_BUF_INIT;
333 int restart;
334 uint8_t extra;
335 int n, m;
336 uint8_t rt_extra;
337
338 - strbuf_addstr(&last_key, "refs/heads/master");
339 - strbuf_addstr(&key, "refs/tags/bla");
338 + reftable_buf_addstr(&last_key, "refs/heads/master");
339 + reftable_buf_addstr(&key, "refs/tags/bla");
340 extra = 6;
341 n = reftable_encode_key(&restart, dest, last_key, key, extra);
342 check(!restart);
343 check_int(n, >, 0);
344
345 - strbuf_addstr(&roundtrip, "refs/heads/master");
345 + reftable_buf_addstr(&roundtrip, "refs/heads/master");
346 m = reftable_decode_key(&roundtrip, &rt_extra, dest);
347 check_int(n, ==, m);
348 - check(!strbuf_cmp(&key, &roundtrip));
348 + check(!reftable_buf_cmp(&key, &roundtrip));
349 check_int(rt_extra, ==, extra);
350
351 - strbuf_release(&last_key);
352 - strbuf_release(&key);
353 - strbuf_release(&roundtrip);
351 + reftable_buf_release(&last_key);
352 + reftable_buf_release(&key);
353 + reftable_buf_release(&roundtrip);
354 }
355
356 static void t_reftable_obj_record_comparison(void)
@@ -413,7 +413,7 @@ static void t_reftable_obj_record_roundtrip(void)
413 .hash_prefix_len = 5,
414 },
415 };
416 - struct strbuf scratch = STRBUF_INIT;
416 + struct reftable_buf scratch = REFTABLE_BUF_INIT;
417
418 for (size_t i = 0; i < ARRAY_SIZE(recs); i++) {
419 uint8_t buffer[1024] = { 0 };
@@ -427,7 +427,7 @@ static void t_reftable_obj_record_roundtrip(void)
427 .obj = recs[i],
428 },
429 };
430 - struct strbuf key = STRBUF_INIT;
430 + struct reftable_buf key = REFTABLE_BUF_INIT;
431 struct reftable_record out = { .type = BLOCK_TYPE_OBJ };
432 int n, m;
433 uint8_t extra;
@@ -443,11 +443,11 @@ static void t_reftable_obj_record_roundtrip(void)
443 check_int(n, ==, m);
444
445 check(reftable_record_equal(&in, &out, GIT_SHA1_RAWSZ));
446 - strbuf_release(&key);
446 + reftable_buf_release(&key);
447 reftable_record_release(&out);
448 }
449
450 - strbuf_release(&scratch);
450 + reftable_buf_release(&scratch);
451 }
452
453 static void t_reftable_index_record_comparison(void)
@@ -456,22 +456,22 @@ static void t_reftable_index_record_comparison(void)
456 {
457 .type = BLOCK_TYPE_INDEX,
458 .u.idx.offset = 22,
459 - .u.idx.last_key = STRBUF_INIT,
459 + .u.idx.last_key = REFTABLE_BUF_INIT,
460 },
461 {
462 .type = BLOCK_TYPE_INDEX,
463 .u.idx.offset = 32,
464 - .u.idx.last_key = STRBUF_INIT,
464 + .u.idx.last_key = REFTABLE_BUF_INIT,
465 },
466 {
467 .type = BLOCK_TYPE_INDEX,
468 .u.idx.offset = 32,
469 - .u.idx.last_key = STRBUF_INIT,
469 + .u.idx.last_key = REFTABLE_BUF_INIT,
470 },
471 };
472 - strbuf_addstr(&in[0].u.idx.last_key, "refs/heads/master");
473 - strbuf_addstr(&in[1].u.idx.last_key, "refs/heads/master");
474 - strbuf_addstr(&in[2].u.idx.last_key, "refs/heads/branch");
472 + reftable_buf_addstr(&in[0].u.idx.last_key, "refs/heads/master");
473 + reftable_buf_addstr(&in[1].u.idx.last_key, "refs/heads/master");
474 + reftable_buf_addstr(&in[2].u.idx.last_key, "refs/heads/branch");
475
476 check(!reftable_record_equal(&in[0], &in[1], GIT_SHA1_RAWSZ));
477 check(!reftable_record_cmp(&in[0], &in[1]));
@@ -493,7 +493,7 @@ static void t_reftable_index_record_roundtrip(void)
493 .type = BLOCK_TYPE_INDEX,
494 .u.idx = {
495 .offset = 42,
496 - .last_key = STRBUF_INIT,
496 + .last_key = REFTABLE_BUF_INIT,
497 },
498 };
499 uint8_t buffer[1024] = { 0 };
@@ -501,21 +501,21 @@ static void t_reftable_index_record_roundtrip(void)
501 .buf = buffer,
502 .len = sizeof(buffer),
503 };
504 - struct strbuf scratch = STRBUF_INIT;
505 - struct strbuf key = STRBUF_INIT;
504 + struct reftable_buf scratch = REFTABLE_BUF_INIT;
505 + struct reftable_buf key = REFTABLE_BUF_INIT;
506 struct reftable_record out = {
507 .type = BLOCK_TYPE_INDEX,
508 - .u.idx = { .last_key = STRBUF_INIT },
508 + .u.idx = { .last_key = REFTABLE_BUF_INIT },
509 };
510 int n, m;
511 uint8_t extra;
512
513 - strbuf_addstr(&in.u.idx.last_key, "refs/heads/master");
513 + reftable_buf_addstr(&in.u.idx.last_key, "refs/heads/master");
514 reftable_record_key(&in, &key);
515 t_copy(&in);
516
517 check(!reftable_record_is_deletion(&in));
518 - check(!strbuf_cmp(&key, &in.u.idx.last_key));
518 + check(!reftable_buf_cmp(&key, &in.u.idx.last_key));
519 n = reftable_record_encode(&in, dest, GIT_SHA1_RAWSZ);
520 check_int(n, >, 0);
521
@@ -527,9 +527,9 @@ static void t_reftable_index_record_roundtrip(void)
527 check(reftable_record_equal(&in, &out, GIT_SHA1_RAWSZ));
528
529 reftable_record_release(&out);
530 - strbuf_release(&key);
531 - strbuf_release(&scratch);
532 - strbuf_release(&in.u.idx.last_key);
530 + reftable_buf_release(&key);
531 + reftable_buf_release(&scratch);
532 + reftable_buf_release(&in.u.idx.last_key);
533 }
534
535 int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
t/unit-tests/t-reftable-stack.c
+45 -45
@@ -16,7 +16,7 @@ https://developers.google.com/open-source/licenses/bsd
16
17 static void clear_dir(const char *dirname)
18 {
19 - struct strbuf path = STRBUF_INIT;
19 + struct strbuf path = REFTABLE_BUF_INIT;
20 strbuf_addstr(&path, dirname);
21 remove_dir_recursively(&path, 0);
22 strbuf_release(&path);
@@ -145,7 +145,7 @@ static int write_test_log(struct reftable_writer *wr, void *arg)
145 static void t_reftable_stack_add_one(void)
146 {
147 char *dir = get_tmp_dir(__LINE__);
148 - struct strbuf scratch = STRBUF_INIT;
148 + struct reftable_buf scratch = REFTABLE_BUF_INIT;
149 int mask = umask(002);
150 struct reftable_write_options opts = {
151 .default_permissions = 0660,
@@ -172,17 +172,17 @@ static void t_reftable_stack_add_one(void)
172 check_int(st->readers_len, >, 0);
173
174 #ifndef GIT_WINDOWS_NATIVE
175 - strbuf_addstr(&scratch, dir);
176 - strbuf_addstr(&scratch, "/tables.list");
175 + reftable_buf_addstr(&scratch, dir);
176 + reftable_buf_addstr(&scratch, "/tables.list");
177 err = stat(scratch.buf, &stat_result);
178 check(!err);
179 check_int((stat_result.st_mode & 0777), ==, opts.default_permissions);
180
181 - strbuf_reset(&scratch);
182 - strbuf_addstr(&scratch, dir);
183 - strbuf_addstr(&scratch, "/");
181 + reftable_buf_reset(&scratch);
182 + reftable_buf_addstr(&scratch, dir);
183 + reftable_buf_addstr(&scratch, "/");
184 /* do not try at home; not an external API for reftable. */
185 - strbuf_addstr(&scratch, st->readers[0]->name);
185 + reftable_buf_addstr(&scratch, st->readers[0]->name);
186 err = stat(scratch.buf, &stat_result);
187 check(!err);
188 check_int((stat_result.st_mode & 0777), ==, opts.default_permissions);
@@ -192,7 +192,7 @@ static void t_reftable_stack_add_one(void)
192
193 reftable_ref_record_release(&dest);
194 reftable_stack_destroy(st);
195 - strbuf_release(&scratch);
195 + reftable_buf_release(&scratch);
196 clear_dir(dir);
197 umask(mask);
198 }
@@ -414,7 +414,7 @@ static void t_reftable_stack_auto_compaction_fails_gracefully(void)
414 };
415 struct reftable_write_options opts = { 0 };
416 struct reftable_stack *st;
417 - struct strbuf table_path = STRBUF_INIT;
417 + struct reftable_buf table_path = REFTABLE_BUF_INIT;
418 char *dir = get_tmp_dir(__LINE__);
419 int err;
420
@@ -432,10 +432,10 @@ static void t_reftable_stack_auto_compaction_fails_gracefully(void)
432 * Adding a new table to the stack should not be impacted by this, even
433 * though auto-compaction will now fail.
434 */
435 - strbuf_addstr(&table_path, dir);
436 - strbuf_addstr(&table_path, "/");
437 - strbuf_addstr(&table_path, st->readers[0]->name);
438 - strbuf_addstr(&table_path, ".lock");
435 + reftable_buf_addstr(&table_path, dir);
436 + reftable_buf_addstr(&table_path, "/");
437 + reftable_buf_addstr(&table_path, st->readers[0]->name);
438 + reftable_buf_addstr(&table_path, ".lock");
439 write_file_buf(table_path.buf, "", 0);
440
441 ref.update_index = 2;
@@ -446,7 +446,7 @@ static void t_reftable_stack_auto_compaction_fails_gracefully(void)
446 check_int(st->stats.failures, ==, 1);
447
448 reftable_stack_destroy(st);
449 - strbuf_release(&table_path);
449 + reftable_buf_release(&table_path);
450 clear_dir(dir);
451 }
452
@@ -516,7 +516,7 @@ static void t_reftable_stack_add(void)
516 char *dir = get_tmp_dir(__LINE__);
517 struct reftable_ref_record refs[2] = { 0 };
518 struct reftable_log_record logs[2] = { 0 };
519 - struct strbuf path = STRBUF_INIT;
519 + struct reftable_buf path = REFTABLE_BUF_INIT;
520 struct stat stat_result;
521 size_t i, N = ARRAY_SIZE(refs);
522
@@ -575,17 +575,17 @@ static void t_reftable_stack_add(void)
575 }
576
577 #ifndef GIT_WINDOWS_NATIVE
578 - strbuf_addstr(&path, dir);
579 - strbuf_addstr(&path, "/tables.list");
578 + reftable_buf_addstr(&path, dir);
579 + reftable_buf_addstr(&path, "/tables.list");
580 err = stat(path.buf, &stat_result);
581 check(!err);
582 check_int((stat_result.st_mode & 0777), ==, opts.default_permissions);
583
584 - strbuf_reset(&path);
585 - strbuf_addstr(&path, dir);
586 - strbuf_addstr(&path, "/");
584 + reftable_buf_reset(&path);
585 + reftable_buf_addstr(&path, dir);
586 + reftable_buf_addstr(&path, "/");
587 /* do not try at home; not an external API for reftable. */
588 - strbuf_addstr(&path, st->readers[0]->name);
588 + reftable_buf_addstr(&path, st->readers[0]->name);
589 err = stat(path.buf, &stat_result);
590 check(!err);
591 check_int((stat_result.st_mode & 0777), ==, opts.default_permissions);
@@ -599,7 +599,7 @@ static void t_reftable_stack_add(void)
599 reftable_ref_record_release(&refs[i]);
600 reftable_log_record_release(&logs[i]);
601 }
602 - strbuf_release(&path);
602 + reftable_buf_release(&path);
603 clear_dir(dir);
604 }
605
@@ -1063,7 +1063,7 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)
1063 .disable_auto_compact = 1,
1064 };
1065 struct reftable_stack *st = NULL;
1066 - struct strbuf buf = STRBUF_INIT;
1066 + struct reftable_buf buf = REFTABLE_BUF_INIT;
1067 char *dir = get_tmp_dir(__LINE__);
1068 int err;
1069
@@ -1078,10 +1078,10 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)
1078 * size, we expect that auto-compaction will want to compact all of the
1079 * tables. Locking any of the tables will keep it from doing so.
1080 */
1081 - strbuf_addstr(&buf, dir);
1082 - strbuf_addstr(&buf, "/");
1083 - strbuf_addstr(&buf, st->readers[2]->name);
1084 - strbuf_addstr(&buf, ".lock");
1081 + reftable_buf_addstr(&buf, dir);
1082 + reftable_buf_addstr(&buf, "/");
1083 + reftable_buf_addstr(&buf, st->readers[2]->name);
1084 + reftable_buf_addstr(&buf, ".lock");
1085 write_file_buf(buf.buf, "", 0);
1086
1087 /*
@@ -1096,7 +1096,7 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)
1096 check_int(st->merged->readers_len, ==, 4);
1097
1098 reftable_stack_destroy(st);
1099 - strbuf_release(&buf);
1099 + reftable_buf_release(&buf);
1100 clear_dir(dir);
1101 }
1102
@@ -1153,7 +1153,7 @@ static void t_reftable_stack_compaction_with_locked_tables(void)
1153 .disable_auto_compact = 1,
1154 };
1155 struct reftable_stack *st = NULL;
1156 - struct strbuf buf = STRBUF_INIT;
1156 + struct reftable_buf buf = REFTABLE_BUF_INIT;
1157 char *dir = get_tmp_dir(__LINE__);
1158 int err;
1159
@@ -1164,10 +1164,10 @@ static void t_reftable_stack_compaction_with_locked_tables(void)
1164 check_int(st->merged->readers_len, ==, 3);
1165
1166 /* Lock one of the tables that we're about to compact. */
1167 - strbuf_addstr(&buf, dir);
1168 - strbuf_addstr(&buf, "/");
1169 - strbuf_addstr(&buf, st->readers[1]->name);
1170 - strbuf_addstr(&buf, ".lock");
1167 + reftable_buf_addstr(&buf, dir);
1168 + reftable_buf_addstr(&buf, "/");
1169 + reftable_buf_addstr(&buf, st->readers[1]->name);
1170 + reftable_buf_addstr(&buf, ".lock");
1171 write_file_buf(buf.buf, "", 0);
1172
1173 /*
@@ -1180,7 +1180,7 @@ static void t_reftable_stack_compaction_with_locked_tables(void)
1180 check_int(st->merged->readers_len, ==, 3);
1181
1182 reftable_stack_destroy(st);
1183 - strbuf_release(&buf);
1183 + reftable_buf_release(&buf);
1184 clear_dir(dir);
1185 }
1186
@@ -1306,7 +1306,7 @@ static void t_reftable_stack_reload_with_missing_table(void)
1306 struct reftable_stack *st = NULL;
1307 struct reftable_ref_record rec = { 0 };
1308 struct reftable_iterator it = { 0 };
1309 - struct strbuf table_path = STRBUF_INIT, content = STRBUF_INIT;
1309 + struct reftable_buf table_path = REFTABLE_BUF_INIT, content = REFTABLE_BUF_INIT;
1310 char *dir = get_tmp_dir(__LINE__);
1311 int err;
1312
@@ -1324,13 +1324,13 @@ static void t_reftable_stack_reload_with_missing_table(void)
1324 * our old readers. This should trigger a partial reload of the stack,
1325 * where we try to reuse our old readers.
1326 */
1327 - strbuf_addstr(&content, st->readers[0]->name);
1328 - strbuf_addstr(&content, "\n");
1329 - strbuf_addstr(&content, st->readers[1]->name);
1330 - strbuf_addstr(&content, "\n");
1331 - strbuf_addstr(&content, "garbage\n");
1332 - strbuf_addstr(&table_path, st->list_file);
1333 - strbuf_addstr(&table_path, ".lock");
1327 + reftable_buf_addstr(&content, st->readers[0]->name);
1328 + reftable_buf_addstr(&content, "\n");
1329 + reftable_buf_addstr(&content, st->readers[1]->name);
1330 + reftable_buf_addstr(&content, "\n");
1331 + reftable_buf_addstr(&content, "garbage\n");
1332 + reftable_buf_addstr(&table_path, st->list_file);
1333 + reftable_buf_addstr(&table_path, ".lock");
1334 write_file_buf(table_path.buf, content.buf, content.len);
1335 err = rename(table_path.buf, st->list_file);
1336 check(!err);
@@ -1355,8 +1355,8 @@ static void t_reftable_stack_reload_with_missing_table(void)
1355 reftable_ref_record_release(&rec);
1356 reftable_iterator_destroy(&it);
1357 reftable_stack_destroy(st);
1358 - strbuf_release(&table_path);
1359 - strbuf_release(&content);
1358 + reftable_buf_release(&table_path);
1359 + reftable_buf_release(&content);
1360 clear_dir(dir);
1361 }
1362