refs.c: make submodule ref store hashmap generic

This removes the "submodule" from submodule_hash_entry and other
function names. The goal is to reuse the same code and data structure
for other ref store types. The first one is worktree ref stores.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/refs.c b/refs.c
index bad05ba8619c65e0143522cdeb220f692a0951bb..96eba924754de02af489d2a104bf5fe0a1b04826 100644 (file)
--- a/refs.c
+++ b/refs.c
@@ -1450,32 +1450,32 @@ int resolve_gitlink_ref(const char *submodule, const char *refname,
        return 0;
 }
 
        return 0;
 }
 

-struct submodule_hash_entry
+struct ref_store_hash_entry

 {
        struct hashmap_entry ent; /* must be the first member! */
 
        struct ref_store *refs;
 
 {
        struct hashmap_entry ent; /* must be the first member! */
 
        struct ref_store *refs;
 

-       /* NUL-terminated name of submodule: */
-       char submodule[FLEX_ARRAY];
+       /* NUL-terminated identifier of the ref store: */
+       char name[FLEX_ARRAY];

 };
 
 };
 

-static int submodule_hash_cmp(const void *entry, const void *entry_or_key,
+static int ref_store_hash_cmp(const void *entry, const void *entry_or_key,

                              const void *keydata)
 {
                              const void *keydata)
 {

-       const struct submodule_hash_entry *e1 = entry, *e2 = entry_or_key;
-       const char *submodule = keydata ? keydata : e2->submodule;
+       const struct ref_store_hash_entry *e1 = entry, *e2 = entry_or_key;
+       const char *name = keydata ? keydata : e2->name;

 
 

-       return strcmp(e1->submodule, submodule);
+       return strcmp(e1->name, name);

 }
 
 }
 

-static struct submodule_hash_entry *alloc_submodule_hash_entry(
-               const char *submodule, struct ref_store *refs)
+static struct ref_store_hash_entry *alloc_ref_store_hash_entry(
+               const char *name, struct ref_store *refs)

 {
 {

-       struct submodule_hash_entry *entry;
+       struct ref_store_hash_entry *entry;

 
 

-       FLEX_ALLOC_STR(entry, submodule, submodule);
-       hashmap_entry_init(entry, strhash(submodule));
+       FLEX_ALLOC_STR(entry, name, name);
+       hashmap_entry_init(entry, strhash(name));

        entry->refs = refs;
        return entry;
 }
        entry->refs = refs;
        return entry;
 }


@@ -1487,19 +1487,19 @@ static struct ref_store *main_ref_store;
 static struct hashmap submodule_ref_stores;
 
 /*
 static struct hashmap submodule_ref_stores;
 
 /*

- * Return the ref_store instance for the specified submodule. If that
- * ref_store hasn't been initialized yet, return NULL.
+ * Look up a ref store by name. If that ref_store hasn't been
+ * registered yet, return NULL.

  */
  */

-static struct ref_store *lookup_submodule_ref_store(const char *submodule)
+static struct ref_store *lookup_ref_store_map(struct hashmap *map,
+                                             const char *name)

 {
 {

-       struct submodule_hash_entry *entry;
+       struct ref_store_hash_entry *entry;

 
 

-       if (!submodule_ref_stores.tablesize)
+       if (!map->tablesize)

                /* It's initialized on demand in register_ref_store(). */
                return NULL;
 
                /* It's initialized on demand in register_ref_store(). */
                return NULL;
 

-       entry = hashmap_get_from_hash(&submodule_ref_stores,
-                                     strhash(submodule), submodule);
+       entry = hashmap_get_from_hash(map, strhash(name), name);

        return entry ? entry->refs : NULL;
 }
 
        return entry ? entry->refs : NULL;
 }
 


@@ -1535,20 +1535,19 @@ struct ref_store *get_main_ref_store(void)
 }
 
 /*
 }
 
 /*

- * Register the specified ref_store to be the one that should be used
- * for submodule. It is a fatal error to call this function twice for
- * the same submodule.
+ * Associate a ref store with a name. It is a fatal error to call this
+ * function twice for the same name.

  */
  */

-static void register_submodule_ref_store(struct ref_store *refs,
-                                        const char *submodule)
+static void register_ref_store_map(struct hashmap *map,
+                                  const char *type,
+                                  struct ref_store *refs,
+                                  const char *name)

 {
 {

-       if (!submodule_ref_stores.tablesize)
-               hashmap_init(&submodule_ref_stores, submodule_hash_cmp, 0);
+       if (!map->tablesize)
+               hashmap_init(map, ref_store_hash_cmp, 0);

 
 

-       if (hashmap_put(&submodule_ref_stores,
-                       alloc_submodule_hash_entry(submodule, refs)))
-               die("BUG: ref_store for submodule '%s' initialized twice",
-                   submodule);
+       if (hashmap_put(map, alloc_ref_store_hash_entry(name, refs)))
+               die("BUG: %s ref_store '%s' initialized twice", type, name);

 }
 
 struct ref_store *get_submodule_ref_store(const char *submodule)
 }
 
 struct ref_store *get_submodule_ref_store(const char *submodule)


@@ -1565,7 +1564,7 @@ struct ref_store *get_submodule_ref_store(const char *submodule)
                return get_main_ref_store();
        }
 
                return get_main_ref_store();
        }
 

-       refs = lookup_submodule_ref_store(submodule);
+       refs = lookup_ref_store_map(&submodule_ref_stores, submodule);

        if (refs)
                return refs;
 
        if (refs)
                return refs;
 


@@ -1584,7 +1583,8 @@ struct ref_store *get_submodule_ref_store(const char *submodule)
        /* assume that add_submodule_odb() has been called */
        refs = ref_store_init(submodule_sb.buf,
                              REF_STORE_READ | REF_STORE_ODB);
        /* assume that add_submodule_odb() has been called */
        refs = ref_store_init(submodule_sb.buf,
                              REF_STORE_READ | REF_STORE_ODB);

-       register_submodule_ref_store(refs, submodule);
+       register_ref_store_map(&submodule_ref_stores, "submodule",
+                              refs, submodule);

 
        strbuf_release(&submodule_sb);
        return refs;
 
        strbuf_release(&submodule_sb);
        return refs;