kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

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>
maint
Nguyễn Thái Ngọc Duy 2017-04-04 17:21:20 +07:00 committed by Junio C Hamano
parent a560d87033
commit 0c064d907b
1 changed files with 32 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
refs.c
View File

@ -1450,32 +1450,32 @@ int resolve_gitlink_ref(const char *submodule, const char *refname,
return 0;
}

struct submodule_hash_entry
struct ref_store_hash_entry
{
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 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;
}
@ -1487,19 +1487,19 @@ static struct ref_store *main_ref_store;
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;

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;
}

@ -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)
@ -1565,7 +1564,7 @@ struct ref_store *get_submodule_ref_store(const char *submodule)
return get_main_ref_store();
}

refs = lookup_submodule_ref_store(submodule);
refs = lookup_ref_store_map(&submodule_ref_stores, submodule);
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);
register_submodule_ref_store(refs, submodule);
register_ref_store_map(&submodule_ref_stores, "submodule",
refs, submodule);

strbuf_release(&submodule_sb);
return refs;