refs: keep track of unresolved reference value in iterators

Since ref iterators do not hold onto the direct value of a reference
without resolving it, the only way to get ahold of a direct value of a
symbolic ref is to make a separate call to refs_read_symbolic_ref.

To make accessing the direct value of a symbolic ref more efficient,
let's save the direct value of the ref in the iterators for both the
files backend and the reftable backend.

Signed-off-by: John Cai <johncai86@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/refs/files-backend.c b/refs/files-backend.c
index aa52d9be7c77ade85967f019cf94121e7903ef20..210adf644fa393e8f630509dcf9cbec655a83c33 100644 (file)
--- a/refs/files-backend.c
+++ b/refs/files-backend.c
@@ -245,9 +245,12 @@ static void loose_fill_ref_dir_regular_file(struct files_ref_store *refs,
 {
        struct object_id oid;
        int flag;
+       const char *referent = refs_resolve_ref_unsafe(&refs->base,
+                                                      refname,
+                                                      RESOLVE_REF_READING,
+                                                      &oid, &flag);
 
-       if (!refs_resolve_ref_unsafe(&refs->base, refname, RESOLVE_REF_READING,
-                                    &oid, &flag)) {
+       if (!referent) {
                oidclr(&oid, the_repository->hash_algo);
                flag |= REF_ISBROKEN;
        } else if (is_null_oid(&oid)) {
@@ -268,7 +271,11 @@ static void loose_fill_ref_dir_regular_file(struct files_ref_store *refs,
                oidclr(&oid, the_repository->hash_algo);
                flag |= REF_BAD_NAME | REF_ISBROKEN;
        }
-       add_entry_to_dir(dir, create_ref_entry(refname, &oid, flag));
+
+       if (!(flag & REF_ISSYMREF))
+               referent = NULL;
+
+       add_entry_to_dir(dir, create_ref_entry(refname, referent, &oid, flag));
 }
 
 /*
@@ -886,6 +893,8 @@ static int files_ref_iterator_advance(struct ref_iterator *ref_iterator)
                iter->base.refname = iter->iter0->refname;
                iter->base.oid = iter->iter0->oid;
                iter->base.flags = iter->iter0->flags;
+               iter->base.referent = iter->iter0->referent;
+
                return ITER_OK;
        }
 

diff --git a/refs/iterator.c b/refs/iterator.c
index d355ebf0d597740e867daf5ddd1bf073622b3aba..75fbe5d72ab036f23fdd23be6d6c6ffa81d35b65 100644 (file)
--- a/refs/iterator.c
+++ b/refs/iterator.c
@@ -29,6 +29,7 @@ void base_ref_iterator_init(struct ref_iterator *iter,
 {
        iter->vtable = vtable;
        iter->refname = NULL;
+       iter->referent = NULL;
        iter->oid = NULL;
        iter->flags = 0;
 }
@@ -199,6 +200,7 @@ static int merge_ref_iterator_advance(struct ref_iterator *ref_iterator)
                }
 
                if (selection & ITER_YIELD_CURRENT) {
+                       iter->base.referent = (*iter->current)->referent;
                        iter->base.refname = (*iter->current)->refname;
                        iter->base.oid = (*iter->current)->oid;
                        iter->base.flags = (*iter->current)->flags;

diff --git a/refs/ref-cache.c b/refs/ref-cache.c
index 4ce519bbc852545874eee6271f51e07eed6c0b64..35bae7e05dedcdbdadbc352ac9e749dc1fc434ff 100644 (file)
--- a/refs/ref-cache.c
+++ b/refs/ref-cache.c
@@ -34,6 +34,7 @@ struct ref_dir *get_ref_dir(struct ref_entry *entry)
 }
 
 struct ref_entry *create_ref_entry(const char *refname,
+                                  const char *referent,
                                   const struct object_id *oid, int flag)
 {
        struct ref_entry *ref;
@@ -41,6 +42,8 @@ struct ref_entry *create_ref_entry(const char *refname,
        FLEX_ALLOC_STR(ref, name, refname);
        oidcpy(&ref->u.value.oid, oid);
        ref->flag = flag;
+       ref->u.value.referent = xstrdup_or_null(referent);
+
        return ref;
 }
 
@@ -66,6 +69,7 @@ static void free_ref_entry(struct ref_entry *entry)
                 */
                clear_ref_dir(&entry->u.subdir);
        }
+       free(entry->u.value.referent);
        free(entry);
 }
 
@@ -431,6 +435,7 @@ static int cache_ref_iterator_advance(struct ref_iterator *ref_iterator)
                        level->index = -1;
                } else {
                        iter->base.refname = entry->name;
+                       iter->base.referent = entry->u.value.referent;
                        iter->base.oid = &entry->u.value.oid;
                        iter->base.flags = entry->flag;
                        return ITER_OK;

diff --git a/refs/ref-cache.h b/refs/ref-cache.h
index 31ebe24f6cf09a10c85cd48d6d1ee849d1f83233..5f04e518c3796d685b0058a170cd5ffd95c233d8 100644 (file)
--- a/refs/ref-cache.h
+++ b/refs/ref-cache.h
@@ -42,6 +42,7 @@ struct ref_value {
         * referred to by the last reference in the symlink chain.
         */
        struct object_id oid;
+       char *referent;
 };
 
 /*
@@ -173,6 +174,7 @@ struct ref_entry *create_dir_entry(struct ref_cache *cache,
                                   const char *dirname, size_t len);
 
 struct ref_entry *create_ref_entry(const char *refname,
+                                  const char *referent,
                                   const struct object_id *oid, int flag);
 
 /*

diff --git a/refs/refs-internal.h b/refs/refs-internal.h
index fa975d69aaabad05ad5aff620f8151039da23937..117ec233848c2de5bcc7693f63f93d2aceb3971b 100644 (file)
--- a/refs/refs-internal.h
+++ b/refs/refs-internal.h
@@ -299,6 +299,7 @@ enum do_for_each_ref_flags {
 struct ref_iterator {
        struct ref_iterator_vtable *vtable;
        const char *refname;
+       const char *referent;
        const struct object_id *oid;
        unsigned int flags;
 };

diff --git a/refs/reftable-backend.c b/refs/reftable-backend.c
index fbe74c239d336bf7404be6f78148a60a450eb637..50a072b97b027aafda39672796ebb59490016d00 100644 (file)
--- a/refs/reftable-backend.c
+++ b/refs/reftable-backend.c
@@ -455,6 +455,7 @@ static int reftable_ref_iterator_advance(struct ref_iterator *ref_iterator)
        struct reftable_ref_iterator *iter =
                (struct reftable_ref_iterator *)ref_iterator;
        struct reftable_ref_store *refs = iter->refs;
+       const char *referent = NULL;
 
        while (!iter->err) {
                int flags = 0;
@@ -494,8 +495,12 @@ static int reftable_ref_iterator_advance(struct ref_iterator *ref_iterator)
                                the_repository->hash_algo);
                        break;
                case REFTABLE_REF_SYMREF:
-                       if (!refs_resolve_ref_unsafe(&iter->refs->base, iter->ref.refname,
-                                                    RESOLVE_REF_READING, &iter->oid, &flags))
+                       referent = refs_resolve_ref_unsafe(&iter->refs->base,
+                                                                     iter->ref.refname,
+                                                                     RESOLVE_REF_READING,
+                                                                     &iter->oid,
+                                                                     &flags);
+                       if (!referent)
                                oidclr(&iter->oid, the_repository->hash_algo);
                        break;
                default:
@@ -523,6 +528,7 @@ static int reftable_ref_iterator_advance(struct ref_iterator *ref_iterator)
                                continue;
 
                iter->base.refname = iter->ref.refname;
+               iter->base.referent = referent;
                iter->base.oid = &iter->oid;
                iter->base.flags = flags;