X-Git-Url: https://git.notmuchmail.org/git?a=blobdiff_plain;ds=sidebyside;f=message.cc;h=b66ca7e2dc3cd7fdeb8a317084f360bd963dc34d;hb=3b8e3ab666a54407f9596a53c66ba8ce623ac91d;hp=ee0e8e1f80502f81aa74c7cfc3994866e852ef41;hpb=db93109cfef2de359a1cbfd3dc2ec08be480745e;p=notmuch

diff --git a/message.cc b/message.cc
index ee0e8e1f..b66ca7e2 100644
--- a/message.cc
+++ b/message.cc
@@ -31,14 +31,18 @@ struct _notmuch_message {
     Xapian::Document doc;
 };
 
-struct _notmuch_tags {
+typedef struct _notmuch_terms {
+    char prefix_char;
     Xapian::TermIterator iterator;
     Xapian::TermIterator iterator_end;
+} notmuch_terms_t;
+
+struct _notmuch_tags {
+    notmuch_terms_t terms;
 };
 
 struct _notmuch_thread_ids {
-    char *current;
-    char *next;
+    notmuch_terms_t terms;
 };
 
 /* "128 bits of thread-id ought to be enough for anybody" */
@@ -48,59 +52,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 <wmorgan-sup@masanjin.net>, 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 +80,43 @@ _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 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. 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->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 +125,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 +149,61 @@ _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);
+
+    if (private_status >= (notmuch_private_status_t) NOTMUCH_STATUS_LAST_STATUS)
+    {
+	fprintf (stderr, "Internal error: Failed to find document immediately after adding it.\n");
+	exit (1);
+    }
+
+    *status = (notmuch_status_t) private_status;
+
+    return message;
 }
 
 const char *
@@ -213,7 +215,7 @@ 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",
@@ -265,52 +267,64 @@ notmuch_message_get_filename (notmuch_message_t *message)
  * talloc_set_destructor at all otherwise).
  */
 static int
-_notmuch_tags_destructor (notmuch_tags_t *tags)
+_notmuch_terms_destructor (notmuch_terms_t *terms)
 {
-    tags->iterator.~TermIterator ();
-    tags->iterator_end.~TermIterator ();
+    terms->iterator.~TermIterator ();
+    terms->iterator_end.~TermIterator ();
 
     return 0;
 }
 
-notmuch_tags_t *
-notmuch_message_get_tags (notmuch_message_t *message)
+notmuch_terms_t *
+_notmuch_terms_create (void *ctx,
+		       Xapian::Document doc,
+		       const char *prefix_name)
 {
-    notmuch_tags_t *tags;
+    notmuch_terms_t *terms;
+    const char *prefix = _find_prefix (prefix_name);
 
-    tags = talloc (message, notmuch_tags_t);
-    if (unlikely (tags == NULL))
+    /* Currently, notmuch_terms_t is written with the assumption that
+     * any prefix its derivatives use will be only a single
+     * character. */
+    assert (strlen (prefix) == 1);
+
+    terms = talloc (ctx, notmuch_terms_t);
+    if (unlikely (terms == NULL))
 	return NULL;
 
-    new (&tags->iterator) Xapian::TermIterator;
-    new (&tags->iterator_end) Xapian::TermIterator;
+    terms->prefix_char = *prefix;
+    new (&terms->iterator) Xapian::TermIterator;
+    new (&terms->iterator_end) Xapian::TermIterator;
+
+    talloc_set_destructor (terms, _notmuch_terms_destructor);
 
-    talloc_set_destructor (tags, _notmuch_tags_destructor);
+    terms->iterator = doc.termlist_begin ();
+    terms->iterator.skip_to (prefix);
+    terms->iterator_end = doc.termlist_end ();
 
-    tags->iterator = message->doc.termlist_begin ();
-    tags->iterator.skip_to (_find_prefix ("tag"));
-    tags->iterator_end = message->doc.termlist_end ();
+    return terms;
+}
 
-    return tags;
+/* 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_t *
+notmuch_message_get_tags (notmuch_message_t *message)
+{
+    return _notmuch_terms_create_type (message, message->doc, "tag",
+				       notmuch_tags_t);
 }
 
 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, "thread",
+				       notmuch_thread_ids_t);
 }
 
 void
@@ -321,7 +335,7 @@ _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));
 }
 
@@ -329,26 +343,7 @@ 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
@@ -388,7 +383,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. */
@@ -514,61 +508,82 @@ notmuch_message_destroy (notmuch_message_t *message)
 }
 
 notmuch_bool_t
-notmuch_tags_has_more (notmuch_tags_t *tags)
+_notmuch_terms_has_more (notmuch_terms_t *terms)
 {
     std::string s;
 
-    if (tags->iterator == tags->iterator_end)
+    if (terms->iterator == terms->iterator_end)
 	return FALSE;
 
-    s = *tags->iterator;
-    if (! s.empty () && s[0] == 'L')
+    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 talloc_strdup (tags, (*tags->iterator).c_str () + 1);
+    return _notmuch_terms_get (&tags->terms);
 }
 
 void
 notmuch_tags_advance (notmuch_tags_t *tags)
 {
-    tags->iterator++;
+    return _notmuch_terms_advance (&tags->terms);
 }
 
 void
 notmuch_tags_destroy (notmuch_tags_t *tags)
 {
-    talloc_free (tags);
+    return _notmuch_terms_destroy (&tags->terms);
 }
 
 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;
+    return _notmuch_terms_has_more (&thread_ids->terms);
 }
 
 const char *
 notmuch_thread_ids_get (notmuch_thread_ids_t *thread_ids)
 {
-    return thread_ids->current;
+    return _notmuch_terms_get (&thread_ids->terms);
 }
 
 void
 notmuch_thread_ids_advance (notmuch_thread_ids_t *thread_ids)
 {
-    thread_ids->current = strsep (&thread_ids->next, ",");
+    return _notmuch_terms_advance (&thread_ids->terms);
 }
 
 void
 notmuch_thread_ids_destroy (notmuch_thread_ids_t *thread_ids)
 {
-    talloc_free (thread_ids);
+    return _notmuch_terms_destroy (&thread_ids->terms);
 }