X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=message.cc;h=21befc20ab0299936b78d374f1cdcd89209bccb6;hp=4e59fce09d980c75687641457195e76e71b00c1f;hb=e37b7cc2da75c9a43e31c1fa6d29f1177445c1d8;hpb=c78358fa8adc0e8fa4f889e479df76e8df186264 diff --git a/message.cc b/message.cc index 4e59fce0..21befc20 100644 --- a/message.cc +++ b/message.cc @@ -27,6 +27,7 @@ struct _notmuch_message { notmuch_database_t *notmuch; Xapian::docid doc_id; char *message_id; + char *filename; Xapian::Document doc; }; @@ -40,58 +41,12 @@ struct _notmuch_thread_ids { char *next; }; -#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 ""; -} +/* "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) +typedef struct _thread_id { + char str[NOTMUCH_THREAD_ID_DIGITS + 1]; +} thread_id_t; /* We end up having to call the destructor explicitly because we had * to use "placement new" in order to initialize C++ objects within a @@ -107,6 +62,22 @@ _notmuch_message_destructor (notmuch_message_t *message) return 0; } +/* Create a new notmuch_message_t object for an existing document in + * the database. + * + * 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. + * + * If no document exists in the database with document ID of 'doc_id' + * then this function returns NULL. + */ notmuch_message_t * _notmuch_message_create (const void *talloc_owner, notmuch_database_t *notmuch, @@ -121,15 +92,65 @@ _notmuch_message_create (const void *talloc_owner, message->notmuch = notmuch; message->doc_id = doc_id; message->message_id = NULL; /* lazily created */ + message->filename = NULL; /* lazily created */ new (&message->doc) Xapian::Document; talloc_set_destructor (message, _notmuch_message_destructor); - message->doc = notmuch->xapian_db->get_document (doc_id); + try { + message->doc = notmuch->xapian_db->get_document (doc_id); + } catch (const Xapian::DocNotFoundError &error) { + talloc_free (message); + return NULL; + } return message; } +/* 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. + * + * 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; + */ +notmuch_message_t * +_notmuch_message_create_for_message_id (const void *talloc_owner, + notmuch_database_t *notmuch, + const char *message_id) +{ + notmuch_message_t *message; + Xapian::Document doc; + unsigned int doc_id; + char *term; + + 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); + + doc.add_value (NOTMUCH_VALUE_MESSAGE_ID, message_id); + + doc_id = notmuch->xapian_db->add_document (doc); + + return _notmuch_message_create (talloc_owner, notmuch, doc_id); +} + const char * notmuch_message_get_message_id (notmuch_message_t *message) { @@ -141,15 +162,49 @@ notmuch_message_get_message_id (notmuch_message_t *message) i = message->doc.termlist_begin (); i.skip_to (_find_prefix ("msgid")); - /* XXX: This should really be an internal error, but we'll need to - * fix the add_message side of things first. */ - if (i == message->doc.termlist_end ()) - return NULL; + 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); + } message->message_id = talloc_strdup (message, (*i).c_str () + 1); return message->message_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. + * + * This change will not be reflected in the database until the next + * call to _notmuch_message_set_sync. */ +void +_notmuch_message_set_filename (notmuch_message_t *message, + const char *filename) +{ + if (message->filename) + talloc_free (message->filename); + message->doc.set_data (filename); +} + +const char * +notmuch_message_get_filename (notmuch_message_t *message) +{ + std::string filename_str; + + if (message->filename) + return message->filename; + + filename_str = message->doc.get_data (); + message->filename = talloc_strdup (message, filename_str.c_str ()); + + 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 @@ -206,6 +261,44 @@ notmuch_message_get_thread_ids (notmuch_message_t *message) } void +_notmuch_message_set_date (notmuch_message_t *message, + const char *date) +{ + time_t time_value; + + time_value = notmuch_parse_date (date, NULL); + + message->doc.add_value (NOTMUCH_VALUE_DATE, + 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) { static int seeded = 0; @@ -234,8 +327,19 @@ thread_id_generate (thread_id_t *thread_id) } } -/* Synchronize changes made to message->doc into the database. */ -static void +void +_notmuch_message_ensure_thread_id (notmuch_message_t *message) +{ + /* If not part of any existing thread, generate a new thread_id. */ + thread_id_t thread_id; + + 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. */ +void _notmuch_message_sync (notmuch_message_t *message) { Xapian::WritableDatabase *db = message->notmuch->xapian_db; @@ -365,7 +469,7 @@ notmuch_tags_has_more (notmuch_tags_t *tags) return FALSE; s = *tags->iterator; - if (s.size () && s[0] == 'L') + if (! s.empty () && s[0] == 'L') return TRUE; else return FALSE;