X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=message.cc;h=6b6141f33fa4dbbd423866c77b1e9eb7c4dfaf6a;hp=75ec63492fd91e94056a72ad6f28725d73772b24;hb=c12823648ee84b4748e0e9f0cd97f7264911b589;hpb=a360670c03475b1489ea5e2327cc3037cc8dff0b diff --git a/message.cc b/message.cc index 75ec6349..6b6141f3 100644 --- a/message.cc +++ b/message.cc @@ -29,18 +29,10 @@ struct _notmuch_message { char *message_id; char *thread_id; char *filename; + notmuch_message_file_t *message_file; Xapian::Document doc; }; -typedef struct _notmuch_terms { - char prefix_char; - Xapian::TermIterator iterator; - Xapian::TermIterator iterator_end; -} notmuch_terms_t; - -struct _notmuch_tags { - notmuch_terms_t terms; -}; /* "128 bits of thread-id ought to be enough for anybody" */ #define NOTMUCH_THREAD_ID_BITS 128 @@ -107,9 +99,12 @@ _notmuch_message_create (const void *talloc_owner, message->notmuch = notmuch; message->doc_id = doc_id; - message->message_id = NULL; /* lazily created */ - message->thread_id = NULL; /* lazily created */ - message->filename = NULL; /* lazily created */ + + /* Each of these will be lazily created as needed. */ + message->message_id = NULL; + message->thread_id = NULL; + message->filename = NULL; + message->message_file = NULL; /* This is C++'s creepy "placement new", which is really just an * ugly way to call a constructor for a pre-allocated object. So @@ -233,6 +228,28 @@ notmuch_message_get_message_id (notmuch_message_t *message) return message->message_id; } +const char * +_notmuch_message_get_subject (notmuch_message_t *message) +{ + if (! message->message_file) { + notmuch_message_file_t *message_file; + const char *filename; + + filename = notmuch_message_get_filename (message); + if (unlikely (filename == NULL)) + return NULL; + + message_file = _notmuch_message_file_open_ctx (message, filename); + if (unlikely (message_file == NULL)) + return NULL; + + message->message_file = message_file; + } + + return notmuch_message_file_get_header (message->message_file, + "subject"); +} + const char * notmuch_message_get_thread_id (notmuch_message_t *message) { @@ -295,64 +312,41 @@ notmuch_message_get_filename (notmuch_message_t *message) return message->filename; } -/* We end up having to call the destructors explicitly because we had - * to use "placement new" in order to initialize C++ objects within a - * block that we allocated with talloc. So C++ is making talloc - * slightly less simple to use, (we wouldn't need - * talloc_set_destructor at all otherwise). - */ -static int -_notmuch_terms_destructor (notmuch_terms_t *terms) -{ - terms->iterator.~TermIterator (); - terms->iterator_end.~TermIterator (); - - return 0; -} - -notmuch_terms_t * -_notmuch_terms_create (void *ctx, - Xapian::Document doc, - const char *prefix_name) +notmuch_tags_t * +notmuch_message_get_tags (notmuch_message_t *message) { - notmuch_terms_t *terms; - const char *prefix = _find_prefix (prefix_name); + const char *prefix = _find_prefix ("tag"); + Xapian::TermIterator i, end; + notmuch_tags_t *tags; + std::string tag; - /* Currently, notmuch_terms_t is written with the assumption that - * any prefix its derivatives use will be only a single - * character. */ + /* Currently this iteration is written with the assumption that + * "tag" has a single-character prefix. */ assert (strlen (prefix) == 1); - terms = talloc (ctx, notmuch_terms_t); - if (unlikely (terms == NULL)) + tags = _notmuch_tags_create (message); + if (unlikely (tags == NULL)) return NULL; - terms->prefix_char = *prefix; - new (&terms->iterator) Xapian::TermIterator; - new (&terms->iterator_end) Xapian::TermIterator; + i = message->doc.termlist_begin (); + end = message->doc.termlist_end (); - talloc_set_destructor (terms, _notmuch_terms_destructor); + i.skip_to (prefix); - terms->iterator = doc.termlist_begin (); - terms->iterator.skip_to (prefix); - terms->iterator_end = doc.termlist_end (); + while (1) { + tag = *i; - return terms; -} + if (tag.empty () || tag[0] != *prefix) + break; -/* The assertion is to ensure that 'type' is a derivative of - * notmuch_terms_t in that it contains a notmuch_terms_t as its first - * member. We do this by name of 'terms' as opposed to type, because - * that's as clever as I've been so far. */ -#define _notmuch_terms_create_type(ctx, doc, prefix_name, type) \ - (COMPILE_TIME_ASSERT(offsetof(type, terms) == 0), \ - (type *) _notmuch_terms_create (ctx, doc, prefix_name)) + _notmuch_tags_add_tag (tags, tag.c_str () + 1); -notmuch_tags_t * -notmuch_message_get_tags (notmuch_message_t *message) -{ - return _notmuch_terms_create_type (message, message->doc, "tag", - notmuch_tags_t); + i++; + } + + _notmuch_tags_prepare_iterator (tags); + + return tags; } void @@ -525,60 +519,3 @@ notmuch_message_destroy (notmuch_message_t *message) { talloc_free (message); } - -notmuch_bool_t -_notmuch_terms_has_more (notmuch_terms_t *terms) -{ - std::string s; - - if (terms->iterator == terms->iterator_end) - return FALSE; - - s = *terms->iterator; - if (! s.empty () && s[0] == terms->prefix_char) - return TRUE; - else - return FALSE; -} - -const char * -_notmuch_terms_get (notmuch_terms_t *terms) -{ - return talloc_strdup (terms, (*terms->iterator).c_str () + 1); -} - -void -_notmuch_terms_advance (notmuch_terms_t *terms) -{ - terms->iterator++; -} - -void -_notmuch_terms_destroy (notmuch_terms_t *terms) -{ - talloc_free (terms); -} - -notmuch_bool_t -notmuch_tags_has_more (notmuch_tags_t *tags) -{ - return _notmuch_terms_has_more (&tags->terms); -} - -const char * -notmuch_tags_get (notmuch_tags_t *tags) -{ - return _notmuch_terms_get (&tags->terms); -} - -void -notmuch_tags_advance (notmuch_tags_t *tags) -{ - return _notmuch_terms_advance (&tags->terms); -} - -void -notmuch_tags_destroy (notmuch_tags_t *tags) -{ - return _notmuch_terms_destroy (&tags->terms); -}