| Message ID | 20201102204344.342633-15-newren@gmail.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | fundamentals of merge-ort implementation | expand |
> +static void write_tree(struct object_id *result_oid, > + struct string_list *versions, > + unsigned int offset) > +{ > + size_t maxlen = 0; > + unsigned int nr = versions->nr - offset; > + struct strbuf buf = STRBUF_INIT; > + struct string_list relevant_entries = STRING_LIST_INIT_NODUP; > + int i; > + > + /* > + * We want to sort the last (versions->nr-offset) entries in versions. > + * Do so by abusing the string_list API a bit: make another string_list > + * that contains just those entries and then sort them. > + * > + * We won't use relevant_entries again and will let it just pop off the > + * stack, so there won't be allocation worries or anything. > + */ > + relevant_entries.items = versions->items + offset; > + relevant_entries.nr = versions->nr - offset; > + string_list_sort(&relevant_entries); > + > + /* Pre-allocate some space in buf */ > + for (i = 0; i < nr; i++) { > + maxlen += strlen(versions->items[offset+i].string) + 34; Probably should include the_hash_algo->rawsz instead of hardcoding 34. The rest looks straightforward.
On Wed, Nov 11, 2020 at 12:47 PM Jonathan Tan <jonathantanmy@google.com> wrote: > > > +static void write_tree(struct object_id *result_oid, > > + struct string_list *versions, > > + unsigned int offset) > > +{ > > + size_t maxlen = 0; > > + unsigned int nr = versions->nr - offset; > > + struct strbuf buf = STRBUF_INIT; > > + struct string_list relevant_entries = STRING_LIST_INIT_NODUP; > > + int i; > > + > > + /* > > + * We want to sort the last (versions->nr-offset) entries in versions. > > + * Do so by abusing the string_list API a bit: make another string_list > > + * that contains just those entries and then sort them. > > + * > > + * We won't use relevant_entries again and will let it just pop off the > > + * stack, so there won't be allocation worries or anything. > > + */ > > + relevant_entries.items = versions->items + offset; > > + relevant_entries.nr = versions->nr - offset; > > + string_list_sort(&relevant_entries); > > + > > + /* Pre-allocate some space in buf */ > > + for (i = 0; i < nr; i++) { > > + maxlen += strlen(versions->items[offset+i].string) + 34; > > Probably should include the_hash_algo->rawsz instead of hardcoding 34. Ah, indeed. And I should submit a patch for fast-import.c to update it to not hardcode 34 either (though I'll submit the fast-import change separate from this series).
diff --git a/merge-ort.c b/merge-ort.c index ff4d455dce..c560dd1634 100644 --- a/merge-ort.c +++ b/merge-ort.c @@ -19,6 +19,7 @@ #include "diff.h" #include "diffcore.h" +#include "object-store.h" #include "strmap.h" #include "tree.h" #include "xdiff-interface.h" @@ -354,6 +355,50 @@ struct directory_versions { struct string_list versions; }; +static void write_tree(struct object_id *result_oid, + struct string_list *versions, + unsigned int offset) +{ + size_t maxlen = 0; + unsigned int nr = versions->nr - offset; + struct strbuf buf = STRBUF_INIT; + struct string_list relevant_entries = STRING_LIST_INIT_NODUP; + int i; + + /* + * We want to sort the last (versions->nr-offset) entries in versions. + * Do so by abusing the string_list API a bit: make another string_list + * that contains just those entries and then sort them. + * + * We won't use relevant_entries again and will let it just pop off the + * stack, so there won't be allocation worries or anything. + */ + relevant_entries.items = versions->items + offset; + relevant_entries.nr = versions->nr - offset; + string_list_sort(&relevant_entries); + + /* Pre-allocate some space in buf */ + for (i = 0; i < nr; i++) { + maxlen += strlen(versions->items[offset+i].string) + 34; + } + strbuf_reset(&buf); + strbuf_grow(&buf, maxlen); + + /* Write each entry out to buf */ + for (i = 0; i < nr; i++) { + struct merged_info *mi = versions->items[offset+i].util; + struct version_info *ri = &mi->result; + strbuf_addf(&buf, "%o %s%c", + ri->mode, + versions->items[offset+i].string, '\0'); + strbuf_add(&buf, ri->oid.hash, the_hash_algo->rawsz); + } + + /* Write this object file out, and record in result_oid */ + write_object_file(buf.buf, buf.len, tree_type, result_oid); + strbuf_release(&buf); +} + static void record_entry_for_tree(struct directory_versions *dir_metadata, const char *path, struct conflict_info *ci) @@ -502,9 +547,16 @@ static void process_entries(struct merge_options *opt, process_entry(opt, path, ci, &dir_metadata); } + /* + * TODO: We can't actually write a tree yet, because dir_metadata just + * contains all basenames of all files throughout the tree with their + * mode and hash. Not only is that a nonsensical tree, it will have + * lots of duplicates for paths such as "Makefile" or ".gitignore". + */ + die("Not yet implemented; need to process subtrees separately"); + write_tree(result_oid, &dir_metadata.versions, 0); string_list_clear(&plist, 0); string_list_clear(&dir_metadata.versions, 0); - die("Tree creation not yet implemented"); } void merge_switch_to_result(struct merge_options *opt,
Create a new function, write_tree(), which will take a list of basenames, modes, and oids for a single directory and create a tree object in the object-store. We do not yet have just basenames, modes, and oids for just a single directory (we have a mixture of entries from all directory levels in the hierarchy) so we still die() before the current call to write_tree(), but the next patch will rectify that. Signed-off-by: Elijah Newren <newren@gmail.com> --- merge-ort.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 53 insertions(+), 1 deletion(-)