midx: split `get_midx_checksum()` by adding `get_midx_hash()`

When trying to print out, say, the hexadecimal representation of a
MIDX's hash, our code will do something like:

    hash_to_hex_algop(get_midx_checksum(m),
                      m->source->odb->repo->hash_algo);

, which is both cumbersome and repetitive. In fact, all but a handful of
callers to `get_midx_checksum()` do exactly the above. Reduce the
repetitive nature of calling `get_midx_checksum()` by having it return a
pointer into a static buffer containing the above result.

For the handful of callers that do need to compare the raw bytes and
don't want to deal with an encoded copy (e.g., because they are passing
it to hasheq() or similar), introduce `get_midx_hash()` which returns
the raw bytes.

Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/midx-write.c b/midx-write.c
index 23e61cb00014282faadf6b5c29636139ad54b082..73d24fabbc63df0a5fd4e08f63a31f94c807110c 100644 (file)
--- a/midx-write.c
+++ b/midx-write.c
@@ -955,7 +955,7 @@ static int link_midx_to_chain(struct multi_pack_index *m)
        }
 
        for (i = 0; i < ARRAY_SIZE(midx_exts); i++) {
-               const unsigned char *hash = get_midx_checksum(m);
+               const unsigned char *hash = get_midx_hash(m);
 
                get_midx_filename_ext(m->source, &from,
                                      hash, midx_exts[i].non_split);
@@ -1086,8 +1086,7 @@ static int write_midx_internal(struct odb_source *source,
                while (m) {
                        if (flags & MIDX_WRITE_BITMAP && load_midx_revindex(m)) {
                                error(_("could not load reverse index for MIDX %s"),
-                                     hash_to_hex_algop(get_midx_checksum(m),
-                                                       m->source->odb->repo->hash_algo));
+                                     get_midx_checksum(m));
                                goto cleanup;
                        }
                        ctx.num_multi_pack_indexes_before++;
@@ -1445,8 +1444,7 @@ static int write_midx_internal(struct odb_source *source,
                for (uint32_t i = 0; i < ctx.num_multi_pack_indexes_before; i++) {
                        uint32_t j = ctx.num_multi_pack_indexes_before - i - 1;
 
-                       keep_hashes[j] = xstrdup(hash_to_hex_algop(get_midx_checksum(m),
-                                                                  r->hash_algo));
+                       keep_hashes[j] = xstrdup(get_midx_checksum(m));
                        m = m->base_midx;
                }
 

diff --git a/midx.c b/midx.c
index 6c01f0fa522f70effe99ceb2ba8b9ec92d40bed6..f9b11de9ca9bd1879e2f517fa4a8d9c59af74225 100644 (file)
--- a/midx.c
+++ b/midx.c
@@ -24,7 +24,13 @@ void clear_incremental_midx_files_ext(struct odb_source *source, const char *ext
 int cmp_idx_or_pack_name(const char *idx_or_pack_name,
                         const char *idx_name);
 
-const unsigned char *get_midx_checksum(const struct multi_pack_index *m)
+const char *get_midx_checksum(const struct multi_pack_index *m)
+{
+       return hash_to_hex_algop(get_midx_hash(m),
+                                m->source->odb->repo->hash_algo);
+}
+
+const unsigned char *get_midx_hash(const struct multi_pack_index *m)
 {
        return m->data + m->data_len - m->source->odb->repo->hash_algo->rawsz;
 }

diff --git a/midx.h b/midx.h
index 7c7e0b5912151b46455e386baa78418f20f26c4f..e188ffeb5789b8463b105cb75d7b8aa8556aa46e 100644 (file)
--- a/midx.h
+++ b/midx.h
@@ -85,7 +85,8 @@ struct multi_pack_index {
 #define MIDX_EXT_BITMAP "bitmap"
 #define MIDX_EXT_MIDX "midx"
 
-const unsigned char *get_midx_checksum(const struct multi_pack_index *m);
+const char *get_midx_checksum(const struct multi_pack_index *m) /* static buffer */;
+const unsigned char *get_midx_hash(const struct multi_pack_index *m);
 void get_midx_filename(struct odb_source *source, struct strbuf *out);
 void get_midx_filename_ext(struct odb_source *source, struct strbuf *out,
                           const unsigned char *hash, const char *ext);

diff --git a/pack-bitmap.c b/pack-bitmap.c
index 8ca79725b1d4380377fc4c0e68141c7fc1968401..f466ed2ddcb4e98f94f5bfe36883f184c1a3e8a0 100644 (file)
--- a/pack-bitmap.c
+++ b/pack-bitmap.c
@@ -441,11 +441,11 @@ char *midx_bitmap_filename(struct multi_pack_index *midx)
        struct strbuf buf = STRBUF_INIT;
        if (midx->has_chain)
                get_split_midx_filename_ext(midx->source, &buf,
-                                           get_midx_checksum(midx),
+                                           get_midx_hash(midx),
                                            MIDX_EXT_BITMAP);
        else
                get_midx_filename_ext(midx->source, &buf,
-                                     get_midx_checksum(midx),
+                                     get_midx_hash(midx),
                                      MIDX_EXT_BITMAP);
 
        return strbuf_detach(&buf, NULL);
@@ -502,7 +502,7 @@ static int open_midx_bitmap_1(struct bitmap_index *bitmap_git,
        if (load_bitmap_header(bitmap_git) < 0)
                goto cleanup;
 
-       if (!hasheq(get_midx_checksum(bitmap_git->midx), bitmap_git->checksum,
+       if (!hasheq(get_midx_hash(bitmap_git->midx), bitmap_git->checksum,
                    bitmap_repo(bitmap_git)->hash_algo)) {
                error(_("checksum doesn't match in MIDX and bitmap"));
                goto cleanup;
@@ -2820,8 +2820,7 @@ void test_bitmap_walk(struct rev_info *revs)
 
                if (bitmap_is_midx(found))
                        fprintf_ln(stderr, "Located via MIDX '%s'.",
-                                  hash_to_hex_algop(get_midx_checksum(found->midx),
-                                                    revs->repo->hash_algo));
+                                  get_midx_checksum(found->midx));
                else
                        fprintf_ln(stderr, "Located via pack '%s'.",
                                   hash_to_hex_algop(found->pack->hash,

diff --git a/pack-revindex.c b/pack-revindex.c
index d0791cc4938fa2c784a1a585210552ee2c6d06fa..016195ceb93ec6891c974a40e40e40964bc54bc3 100644 (file)
--- a/pack-revindex.c
+++ b/pack-revindex.c
@@ -390,11 +390,11 @@ int load_midx_revindex(struct multi_pack_index *m)
 
        if (m->has_chain)
                get_split_midx_filename_ext(m->source, &revindex_name,
-                                           get_midx_checksum(m),
+                                           get_midx_hash(m),
                                            MIDX_EXT_REV);
        else
                get_midx_filename_ext(m->source, &revindex_name,
-                                     get_midx_checksum(m),
+                                     get_midx_hash(m),
                                      MIDX_EXT_REV);
 
        ret = load_revindex_from_disk(m->source->odb->repo->hash_algo,

diff --git a/t/helper/test-read-midx.c b/t/helper/test-read-midx.c
index 6de5d1665afbfc8a6bee29983107cd1c8e28a98b..dee603b3cd0e153ffd67dbb4c4744171aa174f3e 100644 (file)
--- a/t/helper/test-read-midx.c
+++ b/t/helper/test-read-midx.c
@@ -34,7 +34,7 @@ static int read_midx_file(const char *object_dir, const char *checksum,
                return 1;
 
        if (checksum) {
-               while (m && strcmp(hash_to_hex(get_midx_checksum(m)), checksum))
+               while (m && strcmp(get_midx_checksum(m), checksum))
                        m = m->base_midx;
                if (!m)
                        return 1;
@@ -94,7 +94,7 @@ static int read_midx_checksum(const char *object_dir)
        m = setup_midx(object_dir);
        if (!m)
                return 1;
-       printf("%s\n", hash_to_hex(get_midx_checksum(m)));
+       printf("%s\n", get_midx_checksum(m));
 
        close_midx(m);
        return 0;