X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=message.cc;h=2a9001493721dc5493d643659c36afde4f74028b;hp=66dfc806d9f4e887b3fd2b3611667878184f05ea;hb=41c7ad2c91e56bfc0b2fefa0be303605d34f4042;hpb=ef3ab5781a3730e019f92517366029540a960cd0 diff --git a/message.cc b/message.cc index 66dfc806..2a900149 100644 --- a/message.cc +++ b/message.cc @@ -26,13 +26,14 @@ struct _notmuch_message { notmuch_database_t *notmuch; Xapian::docid doc_id; + int frozen; char *message_id; char *thread_id; char *filename; + notmuch_message_file_t *message_file; Xapian::Document doc; }; - /* "128 bits of thread-id ought to be enough for anybody" */ #define NOTMUCH_THREAD_ID_BITS 128 #define NOTMUCH_THREAD_ID_DIGITS (NOTMUCH_THREAD_ID_BITS / 4) @@ -98,9 +99,14 @@ _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 */ + + message->frozen = 0; + + /* 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 @@ -140,7 +146,8 @@ _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, (and *status will be set + * to NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND). * * If an error occurs, this function will return NULL and *status * will be set as appropriate. (The status pointer argument must @@ -150,15 +157,14 @@ notmuch_message_t * _notmuch_message_create_for_message_id (const void *talloc_owner, notmuch_database_t *notmuch, const char *message_id, - notmuch_status_t *status) + notmuch_private_status_t *status_ret) { - notmuch_private_status_t private_status; notmuch_message_t *message; Xapian::Document doc; unsigned int doc_id; char *term; - *status = NOTMUCH_STATUS_SUCCESS; + *status_ret = NOTMUCH_PRIVATE_STATUS_SUCCESS; message = notmuch_database_find_message (notmuch, message_id); if (message) @@ -167,7 +173,7 @@ _notmuch_message_create_for_message_id (const void *talloc_owner, term = talloc_asprintf (NULL, "%s%s", _find_prefix ("id"), message_id); if (term == NULL) { - *status = NOTMUCH_STATUS_OUT_OF_MEMORY; + *status_ret = NOTMUCH_PRIVATE_STATUS_OUT_OF_MEMORY; return NULL; } @@ -179,15 +185,17 @@ _notmuch_message_create_for_message_id (const void *talloc_owner, doc_id = notmuch->xapian_db->add_document (doc); } catch (const Xapian::Error &error) { - *status = NOTMUCH_STATUS_XAPIAN_EXCEPTION; + *status_ret = NOTMUCH_PRIVATE_STATUS_XAPIAN_EXCEPTION; return NULL; } message = _notmuch_message_create (talloc_owner, notmuch, - doc_id, &private_status); + doc_id, status_ret); - *status = COERCE_STATUS (private_status, - "Failed to find dcocument after inserting it."); + /* We want to inform the caller that we had to create a new + * document. */ + if (*status_ret == NOTMUCH_PRIVATE_STATUS_SUCCESS) + *status_ret = NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND; return message; } @@ -224,6 +232,52 @@ notmuch_message_get_message_id (notmuch_message_t *message) return message->message_id; } +static void +_notmuch_message_ensure_message_file (notmuch_message_t *message) +{ + const char *filename; + + if (message->message_file) + return; + + filename = notmuch_message_get_filename (message); + if (unlikely (filename == NULL)) + return; + + message->message_file = _notmuch_message_file_open_ctx (message, filename); +} + +const char * +notmuch_message_get_header (notmuch_message_t *message, const char *header) +{ + _notmuch_message_ensure_message_file (message); + if (message->message_file == NULL) + return NULL; + + return notmuch_message_file_get_header (message->message_file, header); +} + +const char * +notmuch_message_get_all_headers (notmuch_message_t *message) +{ + _notmuch_message_ensure_message_file (message); + if (message->message_file == NULL) + return NULL; + + return notmuch_message_file_get_all_headers (message->message_file); +} + +size_t +notmuch_message_get_header_size (notmuch_message_t *message) +{ + _notmuch_message_ensure_message_file (message); + if (message->message_file == NULL) + return 0; + + return notmuch_message_file_get_header_size (message->message_file); + +} + const char * notmuch_message_get_thread_id (notmuch_message_t *message) { @@ -248,8 +302,10 @@ notmuch_message_get_thread_id (notmuch_message_t *message) 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); + 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); } #endif @@ -267,25 +323,68 @@ void _notmuch_message_set_filename (notmuch_message_t *message, const char *filename) { - if (message->filename) + const char *s; + const char *db_path; + unsigned int db_path_len; + + if (message->filename) { talloc_free (message->filename); - message->doc.set_data (filename); + message->filename = NULL; + } + + if (filename == NULL) + INTERNAL_ERROR ("Message filename cannot be NULL."); + + s = filename; + + db_path = notmuch_database_get_path (message->notmuch); + db_path_len = strlen (db_path); + + if (*s == '/' && strncmp (s, db_path, db_path_len) == 0 + && strlen (s) > db_path_len) + { + s += db_path_len + 1; + } + + message->doc.set_data (s); } const char * notmuch_message_get_filename (notmuch_message_t *message) { std::string filename_str; + const char *db_path; if (message->filename) return message->filename; filename_str = message->doc.get_data (); - message->filename = talloc_strdup (message, filename_str.c_str ()); + db_path = notmuch_database_get_path (message->notmuch); + + if (filename_str[0] != '/') + message->filename = talloc_asprintf (message, "%s/%s", db_path, + filename_str.c_str ()); + else + message->filename = talloc_strdup (message, filename_str.c_str ()); return message->filename; } +time_t +notmuch_message_get_date (notmuch_message_t *message) +{ + std::string value; + + try { + value = message->doc.get_value (NOTMUCH_VALUE_TIMESTAMP); + } catch (Xapian::Error &error) { + INTERNAL_ERROR ("Failed to read timestamp value from document."); + return 0; + } + + return Xapian::sortable_unserialise (value); +} + notmuch_tags_t * notmuch_message_get_tags (notmuch_message_t *message) { @@ -414,6 +513,32 @@ _notmuch_message_add_term (notmuch_message_t *message, return NOTMUCH_PRIVATE_STATUS_SUCCESS; } +/* Parse 'text' and add a term to 'message' for each parsed word. Each + * term will be added both prefixed (if prefix_name is not NULL) and + * also unprefixed). */ +notmuch_private_status_t +_notmuch_message_gen_terms (notmuch_message_t *message, + const char *prefix_name, + const char *text) +{ + Xapian::TermGenerator *term_gen = message->notmuch->term_gen; + + if (text == NULL) + return NOTMUCH_PRIVATE_STATUS_NULL_POINTER; + + term_gen->set_document (message->doc); + + if (prefix_name) { + const char *prefix = _find_prefix (prefix_name); + + term_gen->index_text (text, 1, prefix); + } + + term_gen->index_text (text); + + return NOTMUCH_PRIVATE_STATUS_SUCCESS; +} + /* Remove a name:value term from 'message', (the actual term will be * encoded by prefixing the value with a short prefix). See * NORMAL_PREFIX and BOOLEAN_PREFIX arrays for the mapping of term @@ -437,7 +562,14 @@ _notmuch_message_remove_term (notmuch_message_t *message, if (strlen (term) > NOTMUCH_TERM_MAX) return NOTMUCH_PRIVATE_STATUS_TERM_TOO_LONG; - message->doc.remove_term (term); + try { + message->doc.remove_term (term); + } catch (const Xapian::InvalidArgumentError) { + /* We'll let the philosopher's try to wrestle with the + * question of whether failing to remove that which was not + * there in the first place is failure. For us, we'll silently + * consider it all good. */ + } talloc_free (term); @@ -461,7 +593,8 @@ notmuch_message_add_tag (notmuch_message_t *message, const char *tag) status); } - _notmuch_message_sync (message); + if (! message->frozen) + _notmuch_message_sync (message); return NOTMUCH_STATUS_SUCCESS; } @@ -483,11 +616,55 @@ notmuch_message_remove_tag (notmuch_message_t *message, const char *tag) status); } - _notmuch_message_sync (message); + if (! message->frozen) + _notmuch_message_sync (message); return NOTMUCH_STATUS_SUCCESS; } +void +notmuch_message_remove_all_tags (notmuch_message_t *message) +{ + notmuch_private_status_t status; + notmuch_tags_t *tags; + const char *tag; + + for (tags = notmuch_message_get_tags (message); + notmuch_tags_has_more (tags); + notmuch_tags_advance (tags)) + { + tag = notmuch_tags_get (tags); + + status = _notmuch_message_remove_term (message, "tag", tag); + if (status) { + INTERNAL_ERROR ("_notmuch_message_remove_term return unexpected value: %d\n", + status); + } + } + + if (! message->frozen) + _notmuch_message_sync (message); +} + +void +notmuch_message_freeze (notmuch_message_t *message) +{ + message->frozen++; +} + +notmuch_status_t +notmuch_message_thaw (notmuch_message_t *message) +{ + if (message->frozen > 0) { + message->frozen--; + if (message->frozen == 0) + _notmuch_message_sync (message); + return NOTMUCH_STATUS_SUCCESS; + } else { + return NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW; + } +} + void notmuch_message_destroy (notmuch_message_t *message) {