X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=message.cc;h=f3e39b4b7f2366e711a8a7c8bf892dfbc80f8cc8;hp=65e5ad78a269b6da86ef5a3b7c289871d8096712;hb=2affed0851d85a08f6b0700f7128f97cae6b6024;hpb=ce5d78296251b529838df0dbd4dc3b9a90030924 diff --git a/message.cc b/message.cc index 65e5ad78..f3e39b4b 100644 --- a/message.cc +++ b/message.cc @@ -18,7 +18,7 @@ * Author: Carl Worth */ -#include "notmuch-private.h" +#include "notmuch-private-cxx.h" #include "database-private.h" #include @@ -27,19 +27,11 @@ struct _notmuch_message { notmuch_database_t *notmuch; Xapian::docid doc_id; char *message_id; + char *thread_id; char *filename; Xapian::Document doc; }; -struct _notmuch_tags { - Xapian::TermIterator iterator; - Xapian::TermIterator iterator_end; -}; - -struct _notmuch_thread_ids { - char *current; - char *next; -}; /* "128 bits of thread-id ought to be enough for anybody" */ #define NOTMUCH_THREAD_ID_BITS 128 @@ -48,59 +40,6 @@ typedef struct _thread_id { char str[NOTMUCH_THREAD_ID_DIGITS + 1]; } thread_id_t; -#define ARRAY_SIZE(arr) (sizeof (arr) / sizeof (arr[0])) - -/* These prefix values are specifically chosen to be compatible - * with sup, (http://sup.rubyforge.org), written by - * William Morgan , and released - * under the GNU GPL v2. - */ - -typedef struct { - const char *name; - const char *prefix; -} prefix_t; - -prefix_t NORMAL_PREFIX[] = { - { "subject", "S" }, - { "body", "B" }, - { "from_name", "FN" }, - { "to_name", "TN" }, - { "name", "N" }, - { "attachment", "A" } -}; - -prefix_t BOOLEAN_PREFIX[] = { - { "type", "K" }, - { "from_email", "FE" }, - { "to_email", "TE" }, - { "email", "E" }, - { "date", "D" }, - { "label", "L" }, - { "tag", "L" }, - { "source_id", "I" }, - { "attachment_extension", "O" }, - { "msgid", "Q" }, - { "thread", "H" }, - { "ref", "R" } -}; - -const char * -_find_prefix (const char *name) -{ - unsigned int i; - - for (i = 0; i < ARRAY_SIZE (NORMAL_PREFIX); i++) - if (strcmp (name, NORMAL_PREFIX[i].name) == 0) - return NORMAL_PREFIX[i].prefix; - - for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX); i++) - if (strcmp (name, BOOLEAN_PREFIX[i].name) == 0) - return BOOLEAN_PREFIX[i].prefix; - - return ""; -} - /* We end up having to call the destructor 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 @@ -129,23 +68,46 @@ _notmuch_message_destructor (notmuch_message_t *message) * caller *is* responsible for calling notmuch_message_destroy. * * If no document exists in the database with document ID of 'doc_id' - * then this function returns NULL. + * then this function returns NULL and optionally sets *status to + * NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND. + * + * This function can also fail to due lack of available memory, + * returning NULL and optionally setting *status to + * NOTMUCH_PRIVATE_STATUS_OUT_OF_MEMORY. + * + * The caller can pass NULL for status if uninterested in + * distinguishing these two cases. */ notmuch_message_t * _notmuch_message_create (const void *talloc_owner, notmuch_database_t *notmuch, - unsigned int doc_id) + unsigned int doc_id, + notmuch_private_status_t *status) { notmuch_message_t *message; + if (status) + *status = NOTMUCH_PRIVATE_STATUS_SUCCESS; + message = talloc (talloc_owner, notmuch_message_t); - if (unlikely (message == NULL)) + if (unlikely (message == NULL)) { + if (status) + *status = NOTMUCH_PRIVATE_STATUS_OUT_OF_MEMORY; return NULL; + } 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 */ + + /* This is C++'s creepy "placement new", which is really just an + * ugly way to call a constructor for a pre-allocated object. So + * it's really not an error to not be checking for OUT_OF_MEMORY + * here, since this "new" isn't actually allocating memory. This + * is language-design comedy of the wrong kind. */ + new (&message->doc) Xapian::Document; talloc_set_destructor (message, _notmuch_message_destructor); @@ -154,6 +116,8 @@ _notmuch_message_create (const void *talloc_owner, message->doc = notmuch->xapian_db->get_document (doc_id); } catch (const Xapian::DocNotFoundError &error) { talloc_free (message); + if (status) + *status = NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND; return NULL; } @@ -176,32 +140,56 @@ _notmuch_message_create (const void *talloc_owner, * 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 * document. Otherwise, a new document will be inserted into the - * database before this function returns; + * database before this function returns. + * + * If an error occurs, this function will return NULL and *status + * will be set as appropriate. (The status pointer argument must + * not be NULL.) */ notmuch_message_t * _notmuch_message_create_for_message_id (const void *talloc_owner, notmuch_database_t *notmuch, - const char *message_id) + const char *message_id, + notmuch_status_t *status) { + notmuch_private_status_t private_status; notmuch_message_t *message; Xapian::Document doc; unsigned int doc_id; char *term; + *status = NOTMUCH_STATUS_SUCCESS; + message = notmuch_database_find_message (notmuch, message_id); if (message) return talloc_steal (talloc_owner, message); term = talloc_asprintf (NULL, "%s%s", - _find_prefix ("msgid"), message_id); - doc.add_term (term); - talloc_free (term); + _find_prefix ("id"), message_id); + if (term == NULL) { + *status = NOTMUCH_STATUS_OUT_OF_MEMORY; + return NULL; + } - doc.add_value (NOTMUCH_VALUE_MESSAGE_ID, message_id); + try { + doc.add_term (term); + talloc_free (term); - doc_id = notmuch->xapian_db->add_document (doc); + doc.add_value (NOTMUCH_VALUE_MESSAGE_ID, message_id); - return _notmuch_message_create (talloc_owner, notmuch, doc_id); + doc_id = notmuch->xapian_db->add_document (doc); + } catch (const Xapian::Error &error) { + *status = NOTMUCH_STATUS_XAPIAN_EXCEPTION; + return NULL; + } + + message = _notmuch_message_create (talloc_owner, notmuch, + doc_id, &private_status); + + *status = COERCE_STATUS (private_status, + "Failed to find dcocument after inserting it."); + + return message; } const char * @@ -213,25 +201,65 @@ notmuch_message_get_message_id (notmuch_message_t *message) return message->message_id; i = message->doc.termlist_begin (); - i.skip_to (_find_prefix ("msgid")); + i.skip_to (_find_prefix ("id")); - if (i == message->doc.termlist_end ()) { - fprintf (stderr, "Internal error: Message with document ID of %d has no message ID.\n", - message->doc_id); - exit (1); - } + if (i == message->doc.termlist_end ()) + INTERNAL_ERROR ("Message with document ID of %d has no message ID.\n", + message->doc_id); message->message_id = talloc_strdup (message, (*i).c_str () + 1); + +#if DEBUG_DATABASE_SANITY + i++; + + if (i != message->doc.termlist_end () && + strncmp ((*i).c_str (), _find_prefix ("id"), + strlen (_find_prefix ("id"))) == 0) + { + INTERNAL_ERROR ("Mail (doc_id: %d) has duplicate message IDs", + message->doc_id); + } +#endif + return message->message_id; } +const char * +notmuch_message_get_thread_id (notmuch_message_t *message) +{ + Xapian::TermIterator i; + + 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 ()) + 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); + +#if DEBUG_DATABASE_SANITY + i++; + + if (i != message->doc.termlist_end () && + strncmp ((*i).c_str (), _find_prefix ("thread"), + strlen (_find_prefix ("thread"))) == 0) + { + INTERNAL_ERROR ("Message with document ID of %d has duplicate thread IDs.\n", + message->doc_id); + } +#endif + + return message->thread_id; +} + /* Set the filename for 'message' to 'filename'. * - * XXX: We should still figure out what we want to do for multiple - * files with identical message IDs. We will probably want to store a - * list of filenames here, (so that this will be "add_filename" - * instead of "set_filename"). Which would make this very similar to - * add_thread_ids. + * XXX: We should still figure out if we think it's important to store + * multiple filenames for email messages with identical message IDs. * * This change will not be reflected in the database until the next * call to _notmuch_message_set_sync. */ @@ -258,59 +286,11 @@ 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_tags_destructor (notmuch_tags_t *tags) -{ - tags->iterator.~TermIterator (); - tags->iterator_end.~TermIterator (); - - return 0; -} - notmuch_tags_t * notmuch_message_get_tags (notmuch_message_t *message) { - notmuch_tags_t *tags; - - tags = talloc (message, notmuch_tags_t); - if (unlikely (tags == NULL)) - return NULL; - - new (&tags->iterator) Xapian::TermIterator; - new (&tags->iterator_end) Xapian::TermIterator; - - talloc_set_destructor (tags, _notmuch_tags_destructor); - - tags->iterator = message->doc.termlist_begin (); - tags->iterator.skip_to (_find_prefix ("tag")); - tags->iterator_end = message->doc.termlist_end (); - - return tags; -} - -notmuch_thread_ids_t * -notmuch_message_get_thread_ids (notmuch_message_t *message) -{ - notmuch_thread_ids_t *thread_ids; - std::string id_str; - - thread_ids = talloc (message, notmuch_thread_ids_t); - if (unlikely (thread_ids == NULL)) - return NULL; - - id_str = message->doc.get_value (NOTMUCH_VALUE_THREAD); - thread_ids->next = talloc_strdup (message, id_str.c_str ()); - - /* Initialize thread_ids->current and terminate first ID. */ - notmuch_thread_ids_advance (thread_ids); - - return thread_ids; + return _notmuch_terms_create_type (message, message->doc, "tag", + notmuch_tags_t); } void @@ -321,36 +301,10 @@ _notmuch_message_set_date (notmuch_message_t *message, time_value = notmuch_parse_date (date, NULL); - message->doc.add_value (NOTMUCH_VALUE_DATE, + message->doc.add_value (NOTMUCH_VALUE_TIMESTAMP, Xapian::sortable_serialise (time_value)); } -void -_notmuch_message_add_thread_id (notmuch_message_t *message, - const char *thread_id) -{ - std::string id_str; - - _notmuch_message_add_term (message, "thread", thread_id); - - id_str = message->doc.get_value (NOTMUCH_VALUE_THREAD); - - if (id_str.empty ()) { - message->doc.add_value (NOTMUCH_VALUE_THREAD, thread_id); - } else { - size_t pos; - - /* Think about using a hash here if there's any performance - * problem. */ - pos = id_str.find (thread_id); - if (pos == std::string::npos) { - id_str.append (","); - id_str.append (thread_id); - message->doc.add_value (NOTMUCH_VALUE_THREAD, id_str); - } - } -} - static void thread_id_generate (thread_id_t *thread_id) { @@ -388,7 +342,6 @@ _notmuch_message_ensure_thread_id (notmuch_message_t *message) thread_id_generate (&thread_id); _notmuch_message_add_term (message, "thread", thread_id.str); - message->doc.add_value (NOTMUCH_VALUE_THREAD, thread_id.str); } /* Synchronize changes made to message->doc out into the database. */ @@ -474,9 +427,8 @@ notmuch_message_add_tag (notmuch_message_t *message, const char *tag) status = _notmuch_message_add_term (message, "tag", tag); if (status) { - fprintf (stderr, "Internal error: _notmuch_message_add_term return unexpected value: %d\n", - status); - exit (1); + INTERNAL_ERROR ("_notmuch_message_add_term return unexpected value: %d\n", + status); } _notmuch_message_sync (message); @@ -497,9 +449,8 @@ notmuch_message_remove_tag (notmuch_message_t *message, const char *tag) status = _notmuch_message_remove_term (message, "tag", tag); if (status) { - fprintf (stderr, "Internal error: _notmuch_message_remove_term return unexpected value: %d\n", - status); - exit (1); + INTERNAL_ERROR ("_notmuch_message_remove_term return unexpected value: %d\n", + status); } _notmuch_message_sync (message); @@ -512,63 +463,3 @@ notmuch_message_destroy (notmuch_message_t *message) { talloc_free (message); } - -notmuch_bool_t -notmuch_tags_has_more (notmuch_tags_t *tags) -{ - std::string s; - - if (tags->iterator == tags->iterator_end) - return FALSE; - - s = *tags->iterator; - if (s.size () && s[0] == 'L') - return TRUE; - else - return FALSE; -} - -const char * -notmuch_tags_get (notmuch_tags_t *tags) -{ - return talloc_strdup (tags, (*tags->iterator).c_str () + 1); -} - -void -notmuch_tags_advance (notmuch_tags_t *tags) -{ - tags->iterator++; -} - -void -notmuch_tags_destroy (notmuch_tags_t *tags) -{ - talloc_free (tags); -} - -notmuch_bool_t -notmuch_thread_ids_has_more (notmuch_thread_ids_t *thread_ids) -{ - if (thread_ids->current == NULL || *thread_ids->current == '\0') - return FALSE; - else - return TRUE; -} - -const char * -notmuch_thread_ids_get (notmuch_thread_ids_t *thread_ids) -{ - return thread_ids->current; -} - -void -notmuch_thread_ids_advance (notmuch_thread_ids_t *thread_ids) -{ - thread_ids->current = strsep (&thread_ids->next, ","); -} - -void -notmuch_thread_ids_destroy (notmuch_thread_ids_t *thread_ids) -{ - talloc_free (thread_ids); -}