X-Git-Url: https://git.notmuchmail.org/git?a=blobdiff_plain;f=lib%2Fmessage.cc;h=cb9026439b75647486e4e2b3953da53a8b924e2f;hb=f7eaeff242dd08c4020401c3b2e2e1ad2f769fe0;hp=72c350f32ac2badaa96c15530c1d5b2071db4074;hpb=933caf814fcbbb7420d03ef42bb37bea6dd90449;p=notmuch diff --git a/lib/message.cc b/lib/message.cc index 72c350f3..cb902643 100644 --- a/lib/message.cc +++ b/lib/message.cc @@ -21,6 +21,8 @@ #include "notmuch-private.h" #include "database-private.h" +#include + #include #include @@ -31,6 +33,7 @@ struct _notmuch_message { int frozen; char *message_id; char *thread_id; + char *in_reply_to; char *filename; notmuch_message_file_t *message_file; notmuch_message_list_t *replies; @@ -109,6 +112,7 @@ _notmuch_message_create (const void *talloc_owner, /* Each of these will be lazily created as needed. */ message->message_id = NULL; message->thread_id = NULL; + message->in_reply_to = NULL; message->filename = NULL; message->message_file = NULL; @@ -144,15 +148,8 @@ _notmuch_message_create (const void *talloc_owner, /* Create a new notmuch_message_t object for a specific message ID, * (which may or may not already exist in the databas). * - * Here, 'talloc owner' is an optional talloc context to which the new - * message will belong. This allows for the caller to not bother - * calling notmuch_message_destroy on the message, and no that all - * memory will be reclaimed with 'talloc_owner' is free. The caller - * still can call notmuch_message_destroy when finished with the - * message if desired. - * - * The 'talloc_owner' argument can also be NULL, in which case the - * caller *is* responsible for calling notmuch_message_destroy. + * The 'notmuch' database will be the talloc owner of the returned + * message. * * If there is already a document with message ID 'message_id' in the * database, then the returned message can be used to query/modify the @@ -165,8 +162,7 @@ _notmuch_message_create (const void *talloc_owner, * not be NULL.) */ notmuch_message_t * -_notmuch_message_create_for_message_id (const void *talloc_owner, - notmuch_database_t *notmuch, +_notmuch_message_create_for_message_id (notmuch_database_t *notmuch, const char *message_id, notmuch_private_status_t *status_ret) { @@ -179,7 +175,7 @@ _notmuch_message_create_for_message_id (const void *talloc_owner, message = notmuch_database_find_message (notmuch, message_id); if (message) - return talloc_steal (talloc_owner, message); + return talloc_steal (notmuch, message); term = talloc_asprintf (NULL, "%s%s", _find_prefix ("id"), message_id); @@ -200,7 +196,7 @@ _notmuch_message_create_for_message_id (const void *talloc_owner, return NULL; } - message = _notmuch_message_create (talloc_owner, notmuch, + message = _notmuch_message_create (notmuch, notmuch, doc_id, status_ret); /* We want to inform the caller that we had to create a new @@ -268,46 +264,95 @@ notmuch_message_get_header (notmuch_message_t *message, const char *header) return notmuch_message_file_get_header (message->message_file, header); } -/* XXX: We probably want to store the In-Reply-To header in the - * database (separate from the References message IDs) so that we can - * fetch it out again without having to go load the message file. */ +/* Return the message ID from the In-Reply-To header of 'message'. + * + * Returns an empty string ("") if 'message' has no In-Reply-To + * header. + * + * Returns NULL if any error occurs. + */ const char * _notmuch_message_get_in_reply_to (notmuch_message_t *message) { - return _parse_message_id (message, - notmuch_message_get_header (message, - "in-reply-to"), - NULL); + const char *prefix = _find_prefix ("replyto"); + int prefix_len = strlen (prefix); + Xapian::TermIterator i; + std::string in_reply_to; + + if (message->in_reply_to) + return message->in_reply_to; + + i = message->doc.termlist_begin (); + i.skip_to (prefix); + + in_reply_to = *i; + + /* It's perfectly valid for a message to have no In-Reply-To + * header. For these cases, we return an empty string. */ + if (i == message->doc.termlist_end () || + strncmp (in_reply_to.c_str (), prefix, prefix_len)) + { + message->in_reply_to = talloc_strdup (message, ""); + return message->in_reply_to; + } + + message->in_reply_to = talloc_strdup (message, + in_reply_to.c_str () + prefix_len); + +#if DEBUG_DATABASE_SANITY + i++; + + in_reply_to = *i; + + if (i != message->doc.termlist_end () && + strncmp ((*i).c_str (), prefix, prefix_len)) + { + INTERNAL_ERROR ("Message %s has duplicate In-Reply-To IDs: %s and %s\n" + notmuch_message_get_message_id (message), + message->in_reply_to, + (*i).c_str () + prefix_len); + } +#endif + + return message->in_reply_to; } const char * notmuch_message_get_thread_id (notmuch_message_t *message) { + const char *prefix = _find_prefix ("thread"); Xapian::TermIterator i; + std::string id; + + /* This code is written with the assumption that "thread" has a + * single-character prefix. */ + assert (strlen (prefix) == 1); if (message->thread_id) return message->thread_id; i = message->doc.termlist_begin (); - i.skip_to (_find_prefix ("thread")); - if (i == message->doc.termlist_end ()) + i.skip_to (prefix); + + id = *i; + + if (i == message->doc.termlist_end () || id[0] != *prefix) INTERNAL_ERROR ("Message with document ID of %d has no thread ID.\n", message->doc_id); - message->thread_id = talloc_strdup (message, (*i).c_str () + 1); + message->thread_id = talloc_strdup (message, id.c_str () + 1); #if DEBUG_DATABASE_SANITY i++; + id = *i; - if (i != message->doc.termlist_end () && - strncmp ((*i).c_str (), _find_prefix ("thread"), - strlen (_find_prefix ("thread"))) == 0) + if (i != message->doc.termlist_end () && id[0] == *prefix) { INTERNAL_ERROR ("Message %s has duplicate thread IDs: %s and %s\n", notmuch_message_get_message_id (message), message->thread_id, - (*i).c_str () + 1); + id.c_str () + 1); } #endif