odb: rename `read_object_with_reference()`

Rename `read_object_with_reference()` to `odb_read_object_peeled()` to
match other functions related to the object database and our modern
coding guidelines. Furthermore though, the old name didn't really
describe very well what this function actually does, which is to walk
down any commit and tag objects until an object of the required type has
been found. This is generally referred to as "peeling", so the new name
should be way more descriptive.

No compatibility wrapper is introduces as the function is not used a lot
throughout our codebase.

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

diff --git a/Documentation/user-manual.adoc b/Documentation/user-manual.adoc
index d2b478ad23221ac23fc397481b2c839102ef503c..e86b2ad9f8ab751ad7488cefb01e032ab0668a85 100644 (file)
--- a/Documentation/user-manual.adoc
+++ b/Documentation/user-manual.adoc
@@ -4301,11 +4301,11 @@ Now, for the meat:
 
 -----------------------------------------------------------------------------
         case 0:
-                buf = read_object_with_reference(sha1, argv[1], &size, NULL);
+                buf = odb_read_object_peeled(r->objects, sha1, argv[1], &size, NULL);
 -----------------------------------------------------------------------------
 
 This is how you read a blob (actually, not only a blob, but any type of
-object).  To know how the function `read_object_with_reference()` actually
+object).  To know how the function `odb_read_object_peeled()` actually
 works, find the source code for it (something like `git grep
 read_object_with | grep ":[a-z]"` in the Git repository), and read
 the source.

diff --git a/builtin/cat-file.c b/builtin/cat-file.c
index 01672ec74bd2b8a9aeec70194513a8727fcf7694..08afecbf57cb4bc321ee5601ef6664497f41f464 100644 (file)
--- a/builtin/cat-file.c
+++ b/builtin/cat-file.c
@@ -246,8 +246,8 @@ static int cat_one_file(int opt, const char *exp_type, const char *obj_name)
                         * fall-back to the usual case.
                         */
                }
-               buf = read_object_with_reference(the_repository, &oid,
-                                                exp_type_id, &size, NULL);
+               buf = odb_read_object_peeled(the_repository->objects, &oid,
+                                            exp_type_id, &size, NULL);
 
                if (use_mailmap) {
                        size_t s = size;

diff --git a/builtin/fast-import.c b/builtin/fast-import.c
index 1973c504e257547565a3dedbe8c4fb1ac7322e1e..b1389c59211a485d605f208945183a30d8a73e35 100644 (file)
--- a/builtin/fast-import.c
+++ b/builtin/fast-import.c
@@ -2535,10 +2535,9 @@ static void note_change_n(const char *p, struct branch *b, unsigned char *old_fa
                oidcpy(&commit_oid, &commit_oe->idx.oid);
        } else if (!repo_get_oid(the_repository, p, &commit_oid)) {
                unsigned long size;
-               char *buf = read_object_with_reference(the_repository,
-                                                      &commit_oid,
-                                                      OBJ_COMMIT, &size,
-                                                      &commit_oid);
+               char *buf = odb_read_object_peeled(the_repository->objects,
+                                                  &commit_oid, OBJ_COMMIT, &size,
+                                                  &commit_oid);
                if (!buf || size < the_hash_algo->hexsz + 6)
                        die("Not a valid commit: %s", p);
                free(buf);
@@ -2604,9 +2603,8 @@ static void parse_from_existing(struct branch *b)
                unsigned long size;
                char *buf;
 
-               buf = read_object_with_reference(the_repository,
-                                                &b->oid, OBJ_COMMIT, &size,
-                                                &b->oid);
+               buf = odb_read_object_peeled(the_repository->objects, &b->oid,
+                                            OBJ_COMMIT, &size, &b->oid);
                parse_from_commit(b, buf, size);
                free(buf);
        }
@@ -2699,10 +2697,9 @@ static struct hash_list *parse_merge(unsigned int *count)
                        oidcpy(&n->oid, &oe->idx.oid);
                } else if (!repo_get_oid(the_repository, from, &n->oid)) {
                        unsigned long size;
-                       char *buf = read_object_with_reference(the_repository,
-                                                              &n->oid,
-                                                              OBJ_COMMIT,
-                                                              &size, &n->oid);
+                       char *buf = odb_read_object_peeled(the_repository->objects,
+                                                          &n->oid, OBJ_COMMIT,
+                                                          &size, &n->oid);
                        if (!buf || size < the_hash_algo->hexsz + 6)
                                die("Not a valid commit: %s", from);
                        free(buf);

diff --git a/builtin/grep.c b/builtin/grep.c
index 5de61dfffe893ba0dd190d6f8304ac0d22bf84fc..39273d9c0fd47de5e443a49b7b9ee4dab692c5ba 100644 (file)
--- a/builtin/grep.c
+++ b/builtin/grep.c
@@ -522,9 +522,7 @@ static int grep_submodule(struct grep_opt *opt,
                obj_read_lock();
                object_type = odb_read_object_info(subrepo->objects, oid, NULL);
                obj_read_unlock();
-               data = read_object_with_reference(subrepo,
-                                                 oid, OBJ_TREE,
-                                                 &size, NULL);
+               data = odb_read_object_peeled(subrepo->objects, oid, OBJ_TREE, &size, NULL);
                if (!data)
                        die(_("unable to read tree (%s)"), oid_to_hex(oid));
 
@@ -705,9 +703,8 @@ static int grep_object(struct grep_opt *opt, const struct pathspec *pathspec,
                struct strbuf base;
                int hit, len;
 
-               data = read_object_with_reference(opt->repo,
-                                                 &obj->oid, OBJ_TREE,
-                                                 &size, NULL);
+               data = odb_read_object_peeled(opt->repo->objects, &obj->oid,
+                                             OBJ_TREE, &size, NULL);
                if (!data)
                        die(_("unable to read tree (%s)"), oid_to_hex(&obj->oid));
 

diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c
index 06bdeb4223b6d739fa36be0763fb49269e7dc909..e88a13dbb9f47ee6b4d8614358f4df100b5dbd14 100644 (file)
--- a/builtin/pack-objects.c
+++ b/builtin/pack-objects.c
@@ -2055,8 +2055,8 @@ static void add_preferred_base(struct object_id *oid)
        if (window <= num_preferred_base++)
                return;
 
-       data = read_object_with_reference(the_repository, oid,
-                                         OBJ_TREE, &size, &tree_oid);
+       data = odb_read_object_peeled(the_repository->objects, oid,
+                                     OBJ_TREE, &size, &tree_oid);
        if (!data)
                return;
 

diff --git a/odb.c b/odb.c
index f6231a0556d5f86b2aa1fb8f18069bf26d246548..7d4db7cb49c0ef4618d073f6d70a2fc9d5358274 100644 (file)
--- a/odb.c
+++ b/odb.c
@@ -905,11 +905,11 @@ void *odb_read_object(struct object_database *odb,
        return data;
 }
 
-void *read_object_with_reference(struct repository *r,
-                                const struct object_id *oid,
-                                enum object_type required_type,
-                                unsigned long *size,
-                                struct object_id *actual_oid_return)
+void *odb_read_object_peeled(struct object_database *odb,
+                            const struct object_id *oid,
+                            enum object_type required_type,
+                            unsigned long *size,
+                            struct object_id *actual_oid_return)
 {
        enum object_type type;
        void *buffer;
@@ -921,7 +921,7 @@ void *read_object_with_reference(struct repository *r,
                int ref_length = -1;
                const char *ref_type = NULL;
 
-               buffer = odb_read_object(r->objects, &actual_oid, &type, &isize);
+               buffer = odb_read_object(odb, &actual_oid, &type, &isize);
                if (!buffer)
                        return NULL;
                if (type == required_type) {
@@ -941,9 +941,10 @@ void *read_object_with_reference(struct repository *r,
                }
                ref_length = strlen(ref_type);
 
-               if (ref_length + r->hash_algo->hexsz > isize ||
+               if (ref_length + odb->repo->hash_algo->hexsz > isize ||
                    memcmp(buffer, ref_type, ref_length) ||
-                   get_oid_hex_algop((char *) buffer + ref_length, &actual_oid, r->hash_algo)) {
+                   get_oid_hex_algop((char *) buffer + ref_length, &actual_oid,
+                                     odb->repo->hash_algo)) {
                        free(buffer);
                        return NULL;
                }

diff --git a/odb.h b/odb.h
index e4c51f8c38e9e6d742cf2db6f61b36ebf5ae91ed..e922f256802a0c93392bd97087fc80eec0908794 100644 (file)
--- a/odb.h
+++ b/odb.h
@@ -274,6 +274,12 @@ void *odb_read_object(struct object_database *odb,
                      enum object_type *type,
                      unsigned long *size);
 
+void *odb_read_object_peeled(struct object_database *odb,
+                            const struct object_id *oid,
+                            enum object_type required_type,
+                            unsigned long *size,
+                            struct object_id *oid_ret);
+
 /*
  * Add an object file to the in-memory object store, without writing it
  * to disk.
@@ -382,7 +388,7 @@ void odb_assert_oid_type(struct object_database *odb,
 /*
  * Enabling the object read lock allows multiple threads to safely call the
  * following functions in parallel: odb_read_object(),
- * read_object_with_reference(), odb_read_object_info() and odb().
+ * odb_read_object_peeled(), odb_read_object_info() and odb().
  *
  * obj_read_lock() and obj_read_unlock() may also be used to protect other
  * section which cannot execute in parallel with object reading. Since the used
@@ -431,13 +437,6 @@ enum for_each_object_flags {
        FOR_EACH_OBJECT_SKIP_ON_DISK_KEPT_PACKS = (1<<4),
 };
 
-
-void *read_object_with_reference(struct repository *r,
-                                const struct object_id *oid,
-                                enum object_type required_type,
-                                unsigned long *size,
-                                struct object_id *oid_ret);
-
 /* Compatibility wrappers, to be removed once Git 2.51 has been released. */
 #include "repository.h"
 

diff --git a/tree-walk.c b/tree-walk.c
index 766af99f4668e4efa6c58b54f60d8d673c5da006..e449a1320e55a6069b253f20e167db8c4922fd89 100644 (file)
--- a/tree-walk.c
+++ b/tree-walk.c
@@ -90,7 +90,7 @@ void *fill_tree_descriptor(struct repository *r,
        void *buf = NULL;
 
        if (oid) {
-               buf = read_object_with_reference(r, oid, OBJ_TREE, &size, NULL);
+               buf = odb_read_object_peeled(r->objects, oid, OBJ_TREE, &size, NULL);
                if (!buf)
                        die(_("unable to read tree (%s)"), oid_to_hex(oid));
        }
@@ -611,7 +611,7 @@ int get_tree_entry(struct repository *r,
        unsigned long size;
        struct object_id root;
 
-       tree = read_object_with_reference(r, tree_oid, OBJ_TREE, &size, &root);
+       tree = odb_read_object_peeled(r->objects, tree_oid, OBJ_TREE, &size, &root);
        if (!tree)
                return -1;
 
@@ -681,10 +681,8 @@ enum get_oid_result get_tree_entry_follow_symlinks(struct repository *r,
                        void *tree;
                        struct object_id root;
                        unsigned long size;
-                       tree = read_object_with_reference(r,
-                                                         &current_tree_oid,
-                                                         OBJ_TREE, &size,
-                                                         &root);
+                       tree = odb_read_object_peeled(r->objects, &current_tree_oid,
+                                                     OBJ_TREE, &size, &root);
                        if (!tree)
                                goto done;