refs/reftable: stop using `the_repository`

Convert the reftable ref backend to stop using `the_repository` in favor
of the repo that gets passed in via `struct ref_store`.

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

diff --git a/refs/reftable-backend.c b/refs/reftable-backend.c
index fbe74c239d336bf7404be6f78148a60a450eb637..bf4446afd3c571e38216527cb976337626e51f3a 100644 (file)
--- a/refs/reftable-backend.c
+++ b/refs/reftable-backend.c
@@ -1,5 +1,3 @@
-#define USE_THE_REPOSITORY_VARIABLE
-
 #include "../git-compat-util.h"
 #include "../abspath.h"
 #include "../chdir-notify.h"
@@ -201,7 +199,8 @@ static void fill_reftable_log_record(struct reftable_log_record *log, const stru
        log->value.update.tz_offset = sign * atoi(tz_begin);
 }
 
-static int read_ref_without_reload(struct reftable_stack *stack,
+static int read_ref_without_reload(struct reftable_ref_store *refs,
+                                  struct reftable_stack *stack,
                                   const char *refname,
                                   struct object_id *oid,
                                   struct strbuf *referent,
@@ -220,7 +219,7 @@ static int read_ref_without_reload(struct reftable_stack *stack,
                *type |= REF_ISSYMREF;
        } else if (reftable_ref_record_val1(&ref)) {
                oidread(oid, reftable_ref_record_val1(&ref),
-                       the_repository->hash_algo);
+                       refs->base.repo->hash_algo);
        } else {
                /* We got a tombstone, which should not happen. */
                BUG("unhandled reference value type %d", ref.value_type);
@@ -487,16 +486,16 @@ static int reftable_ref_iterator_advance(struct ref_iterator *ref_iterator)
                switch (iter->ref.value_type) {
                case REFTABLE_REF_VAL1:
                        oidread(&iter->oid, iter->ref.value.val1,
-                               the_repository->hash_algo);
+                               refs->base.repo->hash_algo);
                        break;
                case REFTABLE_REF_VAL2:
                        oidread(&iter->oid, iter->ref.value.val2.value,
-                               the_repository->hash_algo);
+                               refs->base.repo->hash_algo);
                        break;
                case REFTABLE_REF_SYMREF:
                        if (!refs_resolve_ref_unsafe(&iter->refs->base, iter->ref.refname,
                                                     RESOLVE_REF_READING, &iter->oid, &flags))
-                               oidclr(&iter->oid, the_repository->hash_algo);
+                               oidclr(&iter->oid, refs->base.repo->hash_algo);
                        break;
                default:
                        BUG("unhandled reference value type %d", iter->ref.value_type);
@@ -508,7 +507,7 @@ static int reftable_ref_iterator_advance(struct ref_iterator *ref_iterator)
                if (check_refname_format(iter->ref.refname, REFNAME_ALLOW_ONELEVEL)) {
                        if (!refname_is_safe(iter->ref.refname))
                                die(_("refname is dangerous: %s"), iter->ref.refname);
-                       oidclr(&iter->oid, the_repository->hash_algo);
+                       oidclr(&iter->oid, refs->base.repo->hash_algo);
                        flags |= REF_BAD_NAME | REF_ISBROKEN;
                }
 
@@ -551,7 +550,7 @@ static int reftable_ref_iterator_peel(struct ref_iterator *ref_iterator,
 
        if (iter->ref.value_type == REFTABLE_REF_VAL2) {
                oidread(peeled, iter->ref.value.val2.target_value,
-                       the_repository->hash_algo);
+                       iter->refs->base.repo->hash_algo);
                return 0;
        }
 
@@ -659,7 +658,7 @@ static int reftable_be_read_raw_ref(struct ref_store *ref_store,
        if (ret)
                return ret;
 
-       ret = read_ref_without_reload(stack, refname, oid, referent, type);
+       ret = read_ref_without_reload(refs, stack, refname, oid, referent, type);
        if (ret < 0)
                return ret;
        if (ret > 0) {
@@ -868,8 +867,8 @@ static int reftable_be_transaction_prepare(struct ref_store *ref_store,
                goto done;
        }
 
-       ret = read_ref_without_reload(stack_for(refs, "HEAD", NULL), "HEAD", &head_oid,
-                                     &head_referent, &head_type);
+       ret = read_ref_without_reload(refs, stack_for(refs, "HEAD", NULL), "HEAD",
+                                     &head_oid, &head_referent, &head_type);
        if (ret < 0)
                goto done;
        ret = 0;
@@ -936,7 +935,7 @@ static int reftable_be_transaction_prepare(struct ref_store *ref_store,
                        string_list_insert(&affected_refnames, new_update->refname);
                }
 
-               ret = read_ref_without_reload(stack, rewritten_ref,
+               ret = read_ref_without_reload(refs, stack, rewritten_ref,
                                              &current_oid, &referent, &u->type);
                if (ret < 0)
                        goto done;
@@ -1500,7 +1499,8 @@ static int write_copy_table(struct reftable_writer *writer, void *cb_data)
                memcpy(logs[logs_nr].value.update.old_hash, old_ref.value.val1, GIT_MAX_RAWSZ);
                logs_nr++;
 
-               ret = read_ref_without_reload(arg->stack, "HEAD", &head_oid, &head_referent, &head_type);
+               ret = read_ref_without_reload(arg->refs, arg->stack, "HEAD", &head_oid,
+                                             &head_referent, &head_type);
                if (ret < 0)
                        goto done;
                append_head_reflog = (head_type & REF_ISSYMREF) && !strcmp(head_referent.buf, arg->oldname);
@@ -1790,15 +1790,16 @@ static struct ref_iterator *reftable_be_reflog_iterator_begin(struct ref_store *
                                        ref_iterator_select, NULL);
 }
 
-static int yield_log_record(struct reftable_log_record *log,
+static int yield_log_record(struct reftable_ref_store *refs,
+                           struct reftable_log_record *log,
                            each_reflog_ent_fn fn,
                            void *cb_data)
 {
        struct object_id old_oid, new_oid;
        const char *full_committer;
 
-       oidread(&old_oid, log->value.update.old_hash, the_repository->hash_algo);
-       oidread(&new_oid, log->value.update.new_hash, the_repository->hash_algo);
+       oidread(&old_oid, log->value.update.old_hash, refs->base.repo->hash_algo);
+       oidread(&new_oid, log->value.update.new_hash, refs->base.repo->hash_algo);
 
        /*
         * When both the old object ID and the new object ID are null
@@ -1841,7 +1842,7 @@ static int reftable_be_for_each_reflog_ent_reverse(struct ref_store *ref_store,
                        break;
                }
 
-               ret = yield_log_record(&log, fn, cb_data);
+               ret = yield_log_record(refs, &log, fn, cb_data);
                if (ret)
                        break;
        }
@@ -1886,7 +1887,7 @@ static int reftable_be_for_each_reflog_ent(struct ref_store *ref_store,
        }
 
        for (i = logs_nr; i--;) {
-               ret = yield_log_record(&logs[i], fn, cb_data);
+               ret = yield_log_record(refs, &logs[i], fn, cb_data);
                if (ret)
                        goto done;
        }
@@ -2200,7 +2201,7 @@ static int reftable_be_reflog_expire(struct ref_store *ref_store,
                goto done;
        if (reftable_ref_record_val1(&ref_record))
                oidread(&oid, reftable_ref_record_val1(&ref_record),
-                       the_repository->hash_algo);
+                       ref_store->repo->hash_algo);
        prepare_fn(refname, &oid, policy_cb_data);
 
        while (1) {
@@ -2216,9 +2217,9 @@ static int reftable_be_reflog_expire(struct ref_store *ref_store,
                }
 
                oidread(&old_oid, log.value.update.old_hash,
-                       the_repository->hash_algo);
+                       ref_store->repo->hash_algo);
                oidread(&new_oid, log.value.update.new_hash,
-                       the_repository->hash_algo);
+                       ref_store->repo->hash_algo);
 
                /*
                 * Skip over the reflog existence marker. We will add it back
@@ -2250,9 +2251,9 @@ static int reftable_be_reflog_expire(struct ref_store *ref_store,
 
                *dest = logs[i];
                oidread(&old_oid, logs[i].value.update.old_hash,
-                       the_repository->hash_algo);
+                       ref_store->repo->hash_algo);
                oidread(&new_oid, logs[i].value.update.new_hash,
-                       the_repository->hash_algo);
+                       ref_store->repo->hash_algo);
 
                if (should_prune_fn(&old_oid, &new_oid, logs[i].value.update.email,
                                    (timestamp_t)logs[i].value.update.time,
@@ -2269,7 +2270,7 @@ static int reftable_be_reflog_expire(struct ref_store *ref_store,
 
        if (flags & EXPIRE_REFLOGS_UPDATE_REF && last_hash &&
            reftable_ref_record_val1(&ref_record))
-               oidread(&arg.update_oid, last_hash, the_repository->hash_algo);
+               oidread(&arg.update_oid, last_hash, ref_store->repo->hash_algo);
 
        arg.refs = refs;
        arg.records = rewritten;