From: Michael Haggerty <mhagger@xxxxxxxxxxxx>
Instead of iterating through all of the references, inquire more
pointedly about the references that could conflict with the new name.
This requires checking for a few individual references, plus iterating
through a small subtree of the rest of the references (and usually the
subtree iteration ends without having to recurse). A big benefit is
that populating the whole loose reference cache (which can be very
expensive) can usually be avoided.
Also, simplify name_conflict_fn(). Since it now will only be called
for possibly-conflicting references, there is necessarily a conflict
if it is called for *any* reference besides "oldrefname".
Remove function names_conflict(), which is now unused.
Signed-off-by: Michael Haggerty <mhagger@xxxxxxxxxxxx>
---
refs.c | 74 ++++++++++++++++++++++++++++++++++++++++-----------------------
1 files changed, 47 insertions(+), 27 deletions(-)
diff --git a/refs.c b/refs.c
index 3cd8e04..312ca3b 100644
--- a/refs.c
+++ b/refs.c
@@ -591,23 +591,7 @@ static int do_for_each_ref_in_dirs(struct ref_entry *direntry1,
}
}
-/*
- * Return true iff refname1 and refname2 conflict with each other.
- * Two reference names conflict if one of them exactly matches the
- * leading components of the other; e.g., "foo/bar" conflicts with
- * both "foo" and with "foo/bar/baz" but not with "foo/bar" or
- * "foo/barbados".
- */
-static int names_conflict(const char *refname1, const char *refname2)
-{
- for (; *refname1 && *refname1 == *refname2; refname1++, refname2++)
- ;
- return (*refname1 == '\0' && *refname2 == '/')
- || (*refname1 == '/' && *refname2 == '\0');
-}
-
struct name_conflict_cb {
- const char *refname;
const char *oldrefname;
const char *conflicting_refname;
};
@@ -616,31 +600,67 @@ static int name_conflict_fn(const char *existingrefname, const unsigned char *sh
int flags, void *cb_data)
{
struct name_conflict_cb *data = (struct name_conflict_cb *)cb_data;
- if (data->oldrefname && !strcmp(data->oldrefname, existingrefname))
+ if (!strcmp(data->oldrefname, existingrefname))
return 0;
- if (names_conflict(data->refname, existingrefname)) {
- data->conflicting_refname = existingrefname;
- return 1;
- }
- return 0;
+
+ /*
+ * Since we are only iterating over the subtree that has the
+ * new refname as prefix, *any* reference found is a conflict.
+ */
+ data->conflicting_refname = existingrefname;
+ return 1;
}
/*
* Return true iff a reference named refname could be created without
- * conflicting with the name of an existing reference. If oldrefname
- * is non-NULL, ignore potential conflicts with oldrefname (e.g.,
- * because oldrefname is scheduled for deletion in the same
+ * conflicting with the name of an existing reference in direntry. If
+ * oldrefname is non-NULL, ignore potential conflicts with oldrefname
+ * (e.g., because oldrefname is scheduled for deletion in the same
* operation).
+ *
+ * Two reference names conflict if one of them exactly matches the
+ * leading components of the other; e.g., "foo/bar" conflicts with
+ * both "foo" and with "foo/bar/baz" but not with "foo/bar" or
+ * "foo/barbados".
*/
static int is_refname_available(const char *refname, const char *oldrefname,
struct ref_entry *direntry)
{
+ int prefixlen = strlen(refname);
+ char *prefix;
+ char *slash;
struct name_conflict_cb data;
- data.refname = refname;
+
+ assert(direntry->flag & REF_DIR);
+
+ if (!oldrefname)
+ oldrefname = ""; /* invalid; cannot match any existing refname */
+
+ /* Check whether a prefix of refname is an existing reference: */
+ prefix = xmalloc(prefixlen + 2);
+ memcpy(prefix, refname, prefixlen + 1);
+ for (slash = strchr(prefix, '/'); slash; slash = strchr(slash + 1, '/')) {
+ *slash = '\0';
+ if (strcmp(oldrefname, prefix)) {
+ struct ref_entry *entry = find_ref(direntry, prefix);
+ if (entry) {
+ error("'%s' exists; cannot create '%s'", prefix, refname);
+ free(prefix);
+ return 0;
+ }
+ }
+ *slash = '/';
+ }
+
+ /* Check whether refname is a proper prefix of an existing reference: */
+ prefix[prefixlen++] = '/';
+ prefix[prefixlen] = '\0';
data.oldrefname = oldrefname;
data.conflicting_refname = NULL;
- assert(direntry->flag & REF_DIR);
+ direntry = find_containing_direntry(direntry, prefix, 0);
+ if (!direntry)
+ return 1;
if (do_for_each_ref_in_dir(direntry, 0, "", name_conflict_fn,
0, DO_FOR_EACH_INCLUDE_BROKEN,
--
1.7.8
--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html