@matheusbsbs / matheus-bagliano / commits / 73f464b5f3

Fork 0

Refactor notes concatenation into a flexible interface for combining notes

When adding a note to an object that already has an existing note, the current solution is to concatenate the contents of the two notes. However, the caller may instead wish to _overwrite_ the existing note with the new note, or maybe even _ignore_ the new note, and keep the existing one. There might also be other ways of combining notes that are only known to the caller. Therefore, instead of unconditionally concatenating notes, we let the caller specify how to combine notes, by passing in a pointer to a function for combining notes. The caller may choose to implement its own function for notes combining, but normally one of the following three conveniently supplied notes combination functions will be sufficient: - combine_notes_concatenate() combines the two notes by appending the contents of the new note to the contents of the existing note. - combine_notes_overwrite() replaces the existing note with the new note. - combine_notes_ignore() keeps the existing note, and ignores the new note. A combine_notes function can be passed to init_notes() to choose a default combine_notes function for that notes tree. If NULL is given, the notes tree falls back to combine_notes_concatenate() as the ultimate default. A combine_notes function can also be passed directly to add_note(), to control the notes combining behaviour for a note addition in particular. If NULL is passed, the combine_notes function registered for the given notes tree is used. Signed-off-by: Johan Herland <johan@herland.net> Signed-off-by: Junio C Hamano <gitster@pobox.com>

Johan Herland committed Feb 13, 2010 at 22:28 UTC 73f464b5f3fe4dd5109b9fb9e58c1fe55393902d

2 files changed +112 -60

notes.c

+80 -58

@@ -1,5 +1,6 @@

1 #include "cache.h"

2 #include "notes.h"

3 +#include "blob.h"

4 #include "tree.h"

5 #include "utf8.h"

6 #include "strbuf.h"

@@ -127,55 +128,12 @@ static struct leaf_node *note_tree_find(struct int_node *tree, unsigned char n,

128 return NULL;

129 }

130

130 -/* Create a new blob object by concatenating the two given blob objects */

131 -static int concatenate_notes(unsigned char *cur_sha1,

132 - const unsigned char *new_sha1)

133 -{

134 - char *cur_msg, *new_msg, *buf;

135 - unsigned long cur_len, new_len, buf_len;

136 - enum object_type cur_type, new_type;

137 - int ret;

138 -

139 - /* read in both note blob objects */

140 - new_msg = read_sha1_file(new_sha1, &new_type, &new_len);

141 - if (!new_msg || !new_len || new_type != OBJ_BLOB) {

142 - free(new_msg);

143 - return 0;

144 - }

145 - cur_msg = read_sha1_file(cur_sha1, &cur_type, &cur_len);

146 - if (!cur_msg || !cur_len || cur_type != OBJ_BLOB) {

147 - free(cur_msg);

148 - free(new_msg);

149 - hashcpy(cur_sha1, new_sha1);

150 - return 0;

151 - }

152 -

153 - /* we will separate the notes by a newline anyway */

154 - if (cur_msg[cur_len - 1] == '\n')

155 - cur_len--;

156 -

157 - /* concatenate cur_msg and new_msg into buf */

158 - buf_len = cur_len + 1 + new_len;

159 - buf = (char *) xmalloc(buf_len);

160 - memcpy(buf, cur_msg, cur_len);

161 - buf[cur_len] = '\n';

162 - memcpy(buf + cur_len + 1, new_msg, new_len);

163 -

164 - free(cur_msg);

165 - free(new_msg);

166 -

167 - /* create a new blob object from buf */

168 - ret = write_sha1_file(buf, buf_len, "blob", cur_sha1);

169 - free(buf);

170 - return ret;

171 -}

172 -

131 /*

132 * To insert a leaf_node:

133 * Search to the tree location appropriate for the given leaf_node's key:

134 * - If location is unused (NULL), store the tweaked pointer directly there

135 * - If location holds a note entry that matches the note-to-be-inserted, then

178 - * concatenate the two notes.

136 + * combine the two notes (by calling the given combine_notes function).

137 * - If location holds a note entry that matches the subtree-to-be-inserted,

138 * then unpack the subtree-to-be-inserted into the location.

139 * - If location holds a matching subtree entry, unpack the subtree at that

@@ -184,7 +142,8 @@ static int concatenate_notes(unsigned char *cur_sha1,

142 * node-to-be-inserted, and store the new int_node into the location.

143 */

144 static void note_tree_insert(struct int_node *tree, unsigned char n,

187 - struct leaf_node *entry, unsigned char type)

145 + struct leaf_node *entry, unsigned char type,

146 + combine_notes_fn combine_notes)

147 {

148 struct int_node *new_node;

149 struct leaf_node *l;

@@ -205,12 +164,11 @@ static void note_tree_insert(struct int_node *tree, unsigned char n,

164 if (!hashcmp(l->val_sha1, entry->val_sha1))

165 return;

166

208 - if (concatenate_notes(l->val_sha1,

209 - entry->val_sha1))

210 - die("failed to concatenate note %s "

211 - "into note %s for object %s",

212 - sha1_to_hex(entry->val_sha1),

167 + if (combine_notes(l->val_sha1, entry->val_sha1))

168 + die("failed to combine notes %s and %s"

169 + " for object %s",

170 sha1_to_hex(l->val_sha1),

171 + sha1_to_hex(entry->val_sha1),

172 sha1_to_hex(l->key_sha1));

173 free(entry);

174 return;

@@ -233,7 +191,7 @@ static void note_tree_insert(struct int_node *tree, unsigned char n,

191 *p = NULL;

192 load_subtree(l, tree, n);

193 free(l);

236 - note_tree_insert(tree, n, entry, type);

194 + note_tree_insert(tree, n, entry, type, combine_notes);

195 return;

196 }

197 break;

@@ -243,9 +201,9 @@ static void note_tree_insert(struct int_node *tree, unsigned char n,

201 assert(GET_PTR_TYPE(*p) == PTR_TYPE_NOTE ||

202 GET_PTR_TYPE(*p) == PTR_TYPE_SUBTREE);

203 new_node = (struct int_node *) xcalloc(sizeof(struct int_node), 1);

246 - note_tree_insert(new_node, n + 1, l, GET_PTR_TYPE(*p));

204 + note_tree_insert(new_node, n + 1, l, GET_PTR_TYPE(*p), combine_notes);

205 *p = SET_PTR_TYPE(new_node, PTR_TYPE_INTERNAL);

248 - note_tree_insert(new_node, n + 1, entry, type);

206 + note_tree_insert(new_node, n + 1, entry, type, combine_notes);

207 }

208

209 /*

@@ -406,7 +364,8 @@ static void load_subtree(struct leaf_node *subtree, struct int_node *node,

364 l->key_sha1[19] = (unsigned char) len;

365 type = PTR_TYPE_SUBTREE;

366 }

409 - note_tree_insert(node, n, l, type);

367 + note_tree_insert(node, n, l, type,

368 + combine_notes_concatenate);

369 }

370 }

371 free(buf);

@@ -659,7 +618,64 @@ static int write_each_note(const unsigned char *object_sha1,

618 return write_each_note_helper(d->root, note_path, mode, note_sha1);

619 }

620

662 -void init_notes(struct notes_tree *t, const char *notes_ref, int flags)

621 +int combine_notes_concatenate(unsigned char *cur_sha1,

622 + const unsigned char *new_sha1)

623 +{

624 + char *cur_msg = NULL, *new_msg = NULL, *buf;

625 + unsigned long cur_len, new_len, buf_len;

626 + enum object_type cur_type, new_type;

627 + int ret;

628 +

629 + /* read in both note blob objects */

630 + if (!is_null_sha1(new_sha1))

631 + new_msg = read_sha1_file(new_sha1, &new_type, &new_len);

632 + if (!new_msg || !new_len || new_type != OBJ_BLOB) {

633 + free(new_msg);

634 + return 0;

635 + }

636 + if (!is_null_sha1(cur_sha1))

637 + cur_msg = read_sha1_file(cur_sha1, &cur_type, &cur_len);

638 + if (!cur_msg || !cur_len || cur_type != OBJ_BLOB) {

639 + free(cur_msg);

640 + free(new_msg);

641 + hashcpy(cur_sha1, new_sha1);

642 + return 0;

643 + }

644 +

645 + /* we will separate the notes by a newline anyway */

646 + if (cur_msg[cur_len - 1] == '\n')

647 + cur_len--;

648 +

649 + /* concatenate cur_msg and new_msg into buf */

650 + buf_len = cur_len + 1 + new_len;

651 + buf = (char *) xmalloc(buf_len);

652 + memcpy(buf, cur_msg, cur_len);

653 + buf[cur_len] = '\n';

654 + memcpy(buf + cur_len + 1, new_msg, new_len);

655 + free(cur_msg);

656 + free(new_msg);

657 +

658 + /* create a new blob object from buf */

659 + ret = write_sha1_file(buf, buf_len, blob_type, cur_sha1);

660 + free(buf);

661 + return ret;

662 +}

663 +

664 +int combine_notes_overwrite(unsigned char *cur_sha1,

665 + const unsigned char *new_sha1)

666 +{

667 + hashcpy(cur_sha1, new_sha1);

668 + return 0;

669 +}

670 +

671 +int combine_notes_ignore(unsigned char *cur_sha1,

672 + const unsigned char *new_sha1)

673 +{

674 + return 0;

675 +}

676 +

677 +void init_notes(struct notes_tree *t, const char *notes_ref,

678 + combine_notes_fn combine_notes, int flags)

679 {

680 unsigned char sha1[20], object_sha1[20];

681 unsigned mode;

@@ -676,8 +692,12 @@ void init_notes(struct notes_tree *t, const char *notes_ref, int flags)

692 if (!notes_ref)

693 notes_ref = GIT_NOTES_DEFAULT_REF;

694

695 + if (!combine_notes)

696 + combine_notes = combine_notes_concatenate;

697 +

698 t->root = (struct int_node *) xcalloc(sizeof(struct int_node), 1);

699 t->ref = notes_ref ? xstrdup(notes_ref) : NULL;

700 + t->combine_notes = combine_notes;

701 t->initialized = 1;

702

703 if (flags & NOTES_INIT_EMPTY || !notes_ref ||

@@ -693,17 +713,19 @@ void init_notes(struct notes_tree *t, const char *notes_ref, int flags)

713 }

714

715 void add_note(struct notes_tree *t, const unsigned char *object_sha1,

696 - const unsigned char *note_sha1)

716 + const unsigned char *note_sha1, combine_notes_fn combine_notes)

717 {

718 struct leaf_node *l;

719

720 if (!t)

721 t = &default_notes_tree;

722 assert(t->initialized);

723 + if (!combine_notes)

724 + combine_notes = t->combine_notes;

725 l = (struct leaf_node *) xmalloc(sizeof(struct leaf_node));

726 hashcpy(l->key_sha1, object_sha1);

727 hashcpy(l->val_sha1, note_sha1);

706 - note_tree_insert(t->root, 0, l, PTR_TYPE_NOTE);

728 + note_tree_insert(t->root, 0, l, PTR_TYPE_NOTE, combine_notes);

729 }

730

731 void remove_note(struct notes_tree *t, const unsigned char *object_sha1)

@@ -788,7 +810,7 @@ void format_note(struct notes_tree *t, const unsigned char *object_sha1,

810 if (!t)

811 t = &default_notes_tree;

812 if (!t->initialized)

791 - init_notes(t, NULL, 0);

813 + init_notes(t, NULL, NULL, 0);

814

815 sha1 = get_note(t, object_sha1);

816 if (!sha1)

notes.h

+32 -2

@@ -1,6 +1,30 @@

1 #ifndef NOTES_H

2 #define NOTES_H

4 +/*

5 + * Function type for combining two notes annotating the same object.

6 + *

7 + * When adding a new note annotating the same object as an existing note, it is

8 + * up to the caller to decide how to combine the two notes. The decision is

9 + * made by passing in a function of the following form. The function accepts

10 + * two SHA1s -- of the existing note and the new note, respectively. The

11 + * function then combines the notes in whatever way it sees fit, and writes the

12 + * resulting SHA1 into the first SHA1 argument (cur_sha1). A non-zero return

13 + * value indicates failure.

14 + *

15 + * The two given SHA1s must both be non-NULL and different from each other.

16 + *

17 + * The default combine_notes function (you get this when passing NULL) is

18 + * combine_notes_concatenate(), which appends the contents of the new note to

19 + * the contents of the existing note.

20 + */

21 +typedef int combine_notes_fn(unsigned char *cur_sha1, const unsigned char *new_sha1);

22 +

23 +/* Common notes combinators */

24 +int combine_notes_concatenate(unsigned char *cur_sha1, const unsigned char *new_sha1);

25 +int combine_notes_overwrite(unsigned char *cur_sha1, const unsigned char *new_sha1);

26 +int combine_notes_ignore(unsigned char *cur_sha1, const unsigned char *new_sha1);

27 +

28 /*

29 * Notes tree object

30 *

@@ -13,6 +37,7 @@

37 extern struct notes_tree {

38 struct int_node *root;

39 char *ref;

40 + combine_notes_fn *combine_notes;

41 int initialized;

42 } default_notes_tree;

@@ -36,10 +61,15 @@ extern struct notes_tree {

61 *

62 * If you pass t == NULL, the default internal notes_tree will be initialized.

63 *

64 + * The combine_notes function that is passed becomes the default combine_notes

65 + * function for the given notes_tree. If NULL is passed, the default

66 + * combine_notes function is combine_notes_concatenate().

67 + *

68 * Precondition: The notes_tree structure is zeroed (this can be achieved with

69 * memset(t, 0, sizeof(struct notes_tree)))

70 */

42 -void init_notes(struct notes_tree *t, const char *notes_ref, int flags);

71 +void init_notes(struct notes_tree *t, const char *notes_ref,

72 + combine_notes_fn combine_notes, int flags);

74 /*

75 * Add the given note object to the given notes_tree structure

@@ -49,7 +79,7 @@ void init_notes(struct notes_tree *t, const char *notes_ref, int flags);

79 * zero.

80 */

81 void add_note(struct notes_tree *t, const unsigned char *object_sha1,

52 - const unsigned char *note_sha1);

82 + const unsigned char *note_sha1, combine_notes_fn combine_notes);

84 /*

85 * Remove the given note object from the given notes_tree structure