Re: [PATCHv6 13/14] Allow flexible organization of notes trees, using both commit date and SHA1

[Junio C Hamano <gitster@pobox.com>]

Johan Herland <johan@herland.net> writes:

> This is a major expansion of the notes lookup code to allow for variations
> in the notes tree organization. The variations allowed include mixing fanout
> schemes based on the commit dates of the annotated commits (aka. date-based
> fanout) with fanout schemes based on the SHA1 of the annotated commits (aka.
> SHA1-based fanout).

Will squash this in.

-- >8 --
From: Junio C Hamano <gitster@pobox.com>
Date: Sat, 12 Sep 2009 11:36:42 -0700
Subject: [PATCH] notes.[ch] fixup: avoid unnamed struct members

Signed-off-by: Junio C Hamano <gitster@pobox.com>
---
 notes.c |   82 +++++++++++++++++++++++++++++++-------------------------------
 1 files changed, 41 insertions(+), 41 deletions(-)

diff --git a/notes.c b/notes.c
index c573ffa..9a92853 100644
--- a/notes.c
+++ b/notes.c
@@ -118,8 +118,8 @@ struct int_node {
 			struct int_node *parent;
 			unsigned char tree_sha1[20];
 			char period[11];  /* Enough to hold "YYYY-MM-DD" */
-		};
-	};
+		} s;
+	} u;
 };
 
 /*
@@ -182,7 +182,7 @@ static struct leaf_node *note_tree_find(struct int_node *tree, unsigned char n,
 {
 	struct leaf_node *l;
 	unsigned char i = GET_NIBBLE(n, key_sha1);
-	void *p = tree->a[i];
+	void *p = tree->u.a[i];
 
 	switch(GET_PTR_TYPE(p)) {
 	case PTR_TYPE_INTERNAL:
@@ -199,7 +199,7 @@ static struct leaf_node *note_tree_find(struct int_node *tree, unsigned char n,
 		l = (struct leaf_node *) CLR_PTR_TYPE(p);
 		if (!SUBTREE_SHA1_PREFIXCMP(key_sha1, l->key_sha1)) {
 			/* unpack tree and resume search */
-			tree->a[i] = NULL;
+			tree->u.a[i] = NULL;
 			load_subtree(l->val_sha1, l->key_sha1, l->key_sha1[19],
 				     tree, NULL, (int) n);
 			free(l);
@@ -214,16 +214,16 @@ static struct leaf_node *note_tree_find(struct int_node *tree, unsigned char n,
 
 	/*
 	 * Did not find key at this (or any lower) level.
-	 * Check if there's a matching subtree entry in tree->a[0].
+	 * Check if there's a matching subtree entry in tree->u.a[0].
 	 * If so, unpack tree and resume search.
 	 */
-	p = tree->a[0];
+	p = tree->u.a[0];
 	if (GET_PTR_TYPE(p) != PTR_TYPE_SUBTREE)
 		return NULL;
 	l = (struct leaf_node *) CLR_PTR_TYPE(p);
 	if (!SUBTREE_SHA1_PREFIXCMP(key_sha1, l->key_sha1)) {
 		/* unpack tree and resume search */
-		tree->a[0] = NULL;
+		tree->u.a[0] = NULL;
 		load_subtree(l->val_sha1, l->key_sha1, l->key_sha1[19], tree,
 			     NULL, (int) n);
 		free(l);
@@ -250,12 +250,12 @@ static int note_tree_insert(struct int_node *tree, unsigned char n,
 	const struct leaf_node *l;
 	int ret;
 	unsigned char i = GET_NIBBLE(n, entry->key_sha1);
-	void *p = tree->a[i];
+	void *p = tree->u.a[i];
 	assert(GET_PTR_TYPE(entry) == PTR_TYPE_NULL);
 	switch(GET_PTR_TYPE(p)) {
 	case PTR_TYPE_NULL:
 		assert(!p);
-		tree->a[i] = SET_PTR_TYPE(entry, type);
+		tree->u.a[i] = SET_PTR_TYPE(entry, type);
 		return 0;
 	case PTR_TYPE_INTERNAL:
 		return note_tree_insert(CLR_PTR_TYPE(p), n + 1, entry, type);
@@ -273,7 +273,7 @@ static int note_tree_insert(struct int_node *tree, unsigned char n,
 			free(new_node);
 			return -1;
 		}
-		tree->a[i] = SET_PTR_TYPE(new_node, PTR_TYPE_INTERNAL);
+		tree->u.a[i] = SET_PTR_TYPE(new_node, PTR_TYPE_INTERNAL);
 		return note_tree_insert(new_node, n + 1, entry, type);
 	}
 }
@@ -281,20 +281,20 @@ static int note_tree_insert(struct int_node *tree, unsigned char n,
 /* Free the entire notes data contained in the given tree */
 static void note_tree_free(struct int_node *tree)
 {
-	if (tree->magic == (void *) ~0) {
-		if (tree->prev) {
-			note_tree_free(tree->prev);
-			free(tree->prev);
+	if (tree->u.s.magic == (void *) ~0) {
+		if (tree->u.s.prev) {
+			note_tree_free(tree->u.s.prev);
+			free(tree->u.s.prev);
 		}
-		if (tree->child) {
-			note_tree_free(tree->child);
-			free(tree->child);
+		if (tree->u.s.magic) {
+			note_tree_free(tree->u.s.magic);
+			free(tree->u.s.magic);
 		}
 	}
 	else {
 		unsigned int i;
 		for (i = 0; i < 16; i++) {
-			void *p = tree->a[i];
+			void *p = tree->u.a[i];
 			switch(GET_PTR_TYPE(p)) {
 			case PTR_TYPE_INTERNAL:
 				note_tree_free(CLR_PTR_TYPE(p));
@@ -439,12 +439,12 @@ static void load_date_subtree(struct tree_desc *tree_desc,
 		else  /* this is the last entry, store directly into node */
 			new_node = node;
 
-		new_node->magic = (void *) ~0;
-		new_node->child = NULL;
-		new_node->prev = cur_node;
-		new_node->parent = parent;
-		hashcpy(new_node->tree_sha1, entry.sha1);
-		strcpy(new_node->period, period);
+		new_node->u.s.magic = (void *) ~0;
+		new_node->u.s.magic = NULL;
+		new_node->u.s.prev = cur_node;
+		new_node->u.s.parent = parent;
+		hashcpy(new_node->u.s.tree_sha1, entry.sha1);
+		strcpy(new_node->u.s.period, period);
 		cur_node = new_node;
 	}
 	assert(!cur_node || cur_node == node);
@@ -552,38 +552,38 @@ static unsigned char *lookup_notes(const struct commit *commit)
 	/* Convert commit->date to YYYY-MM-DD format */
 	short_date = show_date(commit->date, 0, DATE_SHORT);
 
-	while (node->magic == (void *) ~0) {  /* date-based node */
-		int cmp = SUBTREE_DATE_PREFIXCMP(short_date, node->period);
+	while (node->u.s.magic == (void *) ~0) {  /* date-based node */
+		int cmp = SUBTREE_DATE_PREFIXCMP(short_date, node->u.s.period);
 		if (cmp == 0) {
 			/* Search inside child node */
-			if (!node->child) {
+			if (!node->u.s.magic) {
 				/* Must unpack child node first */
-				node->child = (struct int_node *)
+				node->u.s.magic = (struct int_node *)
 					xcalloc(sizeof(struct int_node), 1);
-				load_subtree(node->tree_sha1,
-					(const unsigned char *) node->period,
-					strlen(node->period), node->child,
+				load_subtree(node->u.s.tree_sha1,
+					(const unsigned char *) node->u.s.period,
+					strlen(node->u.s.period), node->u.s.magic,
 					node, -1);
 			}
 			seen_node = node;
-			node = node->child;
+			node = node->u.s.magic;
 		}
 		else if (cmp > 0) {
 			/* Search in past node */
-			if (node->prev)
-				node = node->prev;
+			if (node->u.s.prev)
+				node = node->u.s.prev;
 			else
-				node = node->parent;
+				node = node->u.s.parent;
 		}
 		else {
 			/* Search in future node */
-			if (!node->parent) {
+			if (!node->u.s.parent) {
 				/* Restart from root_node */
 				seen_node = node;
 				node = &root_node;
 			}
 			else
-				node = node->parent;
+				node = node->u.s.parent;
 		}
 		if (!node || node == seen_node) {
 			/* We've been here before, give up search */
@@ -591,15 +591,15 @@ static unsigned char *lookup_notes(const struct commit *commit)
 		}
 	}
 	while (cur_node &&
-	       SUBTREE_DATE_PREFIXCMP(cur_node->period, seen_node->period) < 0)
+	       SUBTREE_DATE_PREFIXCMP(cur_node->u.s.period, seen_node->u.s.period) < 0)
 	{
 		/*
 		 * We're about to move cur_node backwards in history. We are
 		 * unlikely to need this cur_node in the future, so free() it.
 		 */
-		note_tree_free(cur_node->child);
-		cur_node->child = NULL;
-		cur_node = cur_node->parent;
+		note_tree_free(cur_node->u.s.magic);
+		cur_node->u.s.magic = NULL;
+		cur_node = cur_node->u.s.parent;
 	}
 	cur_node = seen_node;
 
-- 
1.6.5.rc0.82.g1c5d9