loose: refactor object map to operate on `struct odb_source_loose`

While the loose object map functions in "loose.c" accept a generic
`struct odb_source *`, they always expect this to be the "files"
backend. Furthermore, the subsystem doesn't even care about the "files"
backend, but only uses it as a stepping stone to get to the "loose"
backend.

This assumption is implicit and thus not immediately obvious. Refactor
the interfaces to instead operate on a `struct odb_source_loose`
instead, which eliminates the implicit dependency and unnecessary detour
via the "files" source.

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

diff --git a/loose.c b/loose.c
index f7a3dd1a72f0fc32d1f2b42479e609e57dc4baf8..0b626c1b85464209cc7b2be796ab8c8b012ac997 100644 (file)
--- a/loose.c
+++ b/loose.c
@@ -46,38 +46,36 @@ static int insert_oid_pair(kh_oid_map_t *map, const struct object_id *key, const
        return 1;
 }
 
-static int insert_loose_map(struct odb_source *source,
+static int insert_loose_map(struct odb_source_loose *loose,
                            const struct object_id *oid,
                            const struct object_id *compat_oid)
 {
-       struct odb_source_files *files = odb_source_files_downcast(source);
-       struct loose_object_map *map = files->loose->map;
+       struct loose_object_map *map = loose->map;
        int inserted = 0;
 
        inserted |= insert_oid_pair(map->to_compat, oid, compat_oid);
        inserted |= insert_oid_pair(map->to_storage, compat_oid, oid);
        if (inserted)
-               oidtree_insert(files->loose->cache, compat_oid, NULL);
+               oidtree_insert(loose->cache, compat_oid, NULL);
 
        return inserted;
 }
 
-static int load_one_loose_object_map(struct repository *repo, struct odb_source *source)
+static int load_one_loose_object_map(struct repository *repo, struct odb_source_loose *loose)
 {
-       struct odb_source_files *files = odb_source_files_downcast(source);
        struct strbuf buf = STRBUF_INIT, path = STRBUF_INIT;
        FILE *fp;
 
-       if (!files->loose->map)
-               loose_object_map_init(&files->loose->map);
-       if (!files->loose->cache) {
-               ALLOC_ARRAY(files->loose->cache, 1);
-               oidtree_init(files->loose->cache);
+       if (!loose->map)
+               loose_object_map_init(&loose->map);
+       if (!loose->cache) {
+               ALLOC_ARRAY(loose->cache, 1);
+               oidtree_init(loose->cache);
        }
 
-       insert_loose_map(source, repo->hash_algo->empty_tree, repo->compat_hash_algo->empty_tree);
-       insert_loose_map(source, repo->hash_algo->empty_blob, repo->compat_hash_algo->empty_blob);
-       insert_loose_map(source, repo->hash_algo->null_oid, repo->compat_hash_algo->null_oid);
+       insert_loose_map(loose, repo->hash_algo->empty_tree, repo->compat_hash_algo->empty_tree);
+       insert_loose_map(loose, repo->hash_algo->empty_blob, repo->compat_hash_algo->empty_blob);
+       insert_loose_map(loose, repo->hash_algo->null_oid, repo->compat_hash_algo->null_oid);
 
        repo_common_path_replace(repo, &path, "objects/loose-object-idx");
        fp = fopen(path.buf, "rb");
@@ -97,7 +95,7 @@ static int load_one_loose_object_map(struct repository *repo, struct odb_source
                    parse_oid_hex_algop(p, &compat_oid, &p, repo->compat_hash_algo) ||
                    p != buf.buf + buf.len)
                        goto err;
-               insert_loose_map(source, &oid, &compat_oid);
+               insert_loose_map(loose, &oid, &compat_oid);
        }
 
        strbuf_release(&buf);
@@ -119,7 +117,8 @@ int repo_read_loose_object_map(struct repository *repo)
        odb_prepare_alternates(repo->objects);
 
        for (source = repo->objects->sources; source; source = source->next) {
-               if (load_one_loose_object_map(repo, source) < 0) {
+               struct odb_source_files *files = odb_source_files_downcast(source);
+               if (load_one_loose_object_map(repo, files->loose) < 0) {
                        return -1;
                }
        }
@@ -171,7 +170,7 @@ errout:
        return -1;
 }
 
-static int write_one_object(struct odb_source *source,
+static int write_one_object(struct odb_source_loose *loose,
                            const struct object_id *oid,
                            const struct object_id *compat_oid)
 {
@@ -180,7 +179,7 @@ static int write_one_object(struct odb_source *source,
        struct stat st;
        struct strbuf buf = STRBUF_INIT, path = STRBUF_INIT;
 
-       strbuf_addf(&path, "%s/loose-object-idx", source->path);
+       strbuf_addf(&path, "%s/loose-object-idx", loose->base.path);
        hold_lock_file_for_update_timeout(&lock, path.buf, LOCK_DIE_ON_ERROR, -1);
 
        fd = open(path.buf, O_WRONLY | O_CREAT | O_APPEND, 0666);
@@ -196,7 +195,7 @@ static int write_one_object(struct odb_source *source,
                goto errout;
        if (close(fd))
                goto errout;
-       adjust_shared_perm(source->odb->repo, path.buf);
+       adjust_shared_perm(loose->base.odb->repo, path.buf);
        rollback_lock_file(&lock);
        strbuf_release(&buf);
        strbuf_release(&path);
@@ -210,18 +209,18 @@ errout:
        return -1;
 }
 
-int repo_add_loose_object_map(struct odb_source *source,
+int repo_add_loose_object_map(struct odb_source_loose *loose,
                              const struct object_id *oid,
                              const struct object_id *compat_oid)
 {
        int inserted = 0;
 
-       if (!should_use_loose_object_map(source->odb->repo))
+       if (!should_use_loose_object_map(loose->base.odb->repo))
                return 0;
 
-       inserted = insert_loose_map(source, oid, compat_oid);
+       inserted = insert_loose_map(loose, oid, compat_oid);
        if (inserted)
-               return write_one_object(source, oid, compat_oid);
+               return write_one_object(loose, oid, compat_oid);
        return 0;
 }
 

diff --git a/loose.h b/loose.h
index 6af1702973c05883f942201d5a3bb978e3cea9dd..6c9b3f4571602f1a5798bb38ab9dc728d1a630de 100644 (file)
--- a/loose.h
+++ b/loose.h
@@ -4,7 +4,7 @@
 #include "khash.h"
 
 struct repository;
-struct odb_source;
+struct odb_source_loose;
 
 struct loose_object_map {
        kh_oid_map_t *to_compat;
@@ -17,7 +17,7 @@ int repo_loose_object_map_oid(struct repository *repo,
                              const struct object_id *src,
                              const struct git_hash_algo *dest_algo,
                              struct object_id *dest);
-int repo_add_loose_object_map(struct odb_source *source,
+int repo_add_loose_object_map(struct odb_source_loose *loose,
                              const struct object_id *oid,
                              const struct object_id *compat_oid);
 int repo_read_loose_object_map(struct repository *repo);

diff --git a/object-file.c b/object-file.c
index 0689a4e67b156a1cddd2425af9cc9de41095f5b0..fe24f00d1b79bf3287462797d91949c55ede73e7 100644 (file)
--- a/object-file.c
+++ b/object-file.c
@@ -810,6 +810,7 @@ int odb_source_loose_write_stream(struct odb_source *source,
                                  struct odb_write_stream *in_stream, size_t len,
                                  struct object_id *oid)
 {
+       struct odb_source_files *files = odb_source_files_downcast(source);
        const struct git_hash_algo *compat = source->odb->repo->compat_hash_algo;
        struct object_id compat_oid;
        int fd, ret, err = 0, flush = 0;
@@ -918,7 +919,7 @@ int odb_source_loose_write_stream(struct odb_source *source,
        err = finalize_object_file_flags(source->odb->repo, tmp_file.buf, filename.buf,
                                         FOF_SKIP_COLLISION_CHECK);
        if (!err && compat)
-               err = repo_add_loose_object_map(source, oid, &compat_oid);
+               err = repo_add_loose_object_map(files->loose, oid, &compat_oid);
 cleanup:
        strbuf_release(&tmp_file);
        strbuf_release(&filename);
@@ -931,6 +932,7 @@ int odb_source_loose_write_object(struct odb_source *source,
                                  struct object_id *compat_oid_in,
                                  enum odb_write_object_flags flags)
 {
+       struct odb_source_files *files = odb_source_files_downcast(source);
        const struct git_hash_algo *algo = source->odb->repo->hash_algo;
        const struct git_hash_algo *compat = source->odb->repo->compat_hash_algo;
        struct object_id compat_oid;
@@ -962,13 +964,14 @@ int odb_source_loose_write_object(struct odb_source *source,
        if (write_loose_object(source, oid, hdr, hdrlen, buf, len, 0, flags))
                return -1;
        if (compat)
-               return repo_add_loose_object_map(source, oid, &compat_oid);
+               return repo_add_loose_object_map(files->loose, oid, &compat_oid);
        return 0;
 }
 
 int force_object_loose(struct odb_source *source,
                       const struct object_id *oid, time_t mtime)
 {
+       struct odb_source_files *files = odb_source_files_downcast(source);
        const struct git_hash_algo *compat = source->odb->repo->compat_hash_algo;
        void *buf;
        unsigned long len;
@@ -998,7 +1001,7 @@ int force_object_loose(struct odb_source *source,
        hdrlen = format_object_header(hdr, sizeof(hdr), type, len);
        ret = write_loose_object(source, oid, hdr, hdrlen, buf, len, mtime, 0);
        if (!ret && compat)
-               ret = repo_add_loose_object_map(source, oid, &compat_oid);
+               ret = repo_add_loose_object_map(files->loose, oid, &compat_oid);
        free(buf);
 
        return ret;