get_in_reply_to: Implement via the database, not by opening mail file.

[notmuch] / lib / thread.cc

diff --git a/lib/thread.cc b/lib/thread.cc
index df1d0db7fae0ac0f4e8d8f6c400d31dc09b2b3b6..e38a5b2e0abc336bd16fe03de8cb82902abd984d 100644 (file)
--- a/lib/thread.cc
+++ b/lib/thread.cc
@@ -34,6 +34,8 @@ struct _notmuch_thread {
     char *authors;
     GHashTable *tags;
 
+    notmuch_message_list_t *message_list;
+    GHashTable *message_hash;
     int total_messages;
     int matched_messages;
     time_t oldest;
@@ -45,6 +47,7 @@ _notmuch_thread_destructor (notmuch_thread_t *thread)
 {
     g_hash_table_unref (thread->authors_hash);
     g_hash_table_unref (thread->tags);
+    g_hash_table_unref (thread->message_hash);
 
     return 0;
 }
@@ -70,17 +73,29 @@ _thread_add_author (notmuch_thread_t *thread,
        thread->authors = talloc_strdup (thread, author);
 }
 
+/* Add 'message' as a message that belongs to 'thread'.
+ *
+ * The 'thread' will talloc_steal the 'message' and hold onto a
+ * reference to it.
+ */
 static void
 _thread_add_message (notmuch_thread_t *thread,
                     notmuch_message_t *message)
 {
     notmuch_tags_t *tags;
     const char *tag;
-    time_t date;
     InternetAddressList *list;
     InternetAddress *address;
     const char *from, *author;
 
+    _notmuch_message_list_add_message (thread->message_list,
+                                      talloc_steal (thread, message));
+    thread->total_messages++;
+
+    g_hash_table_insert (thread->message_hash,
+                        xstrdup (notmuch_message_get_message_id (message)),
+                        message);
+
     from = notmuch_message_get_header (message, "from");
     list = internet_address_list_parse_string (from);
     if (list) {
@@ -110,16 +125,61 @@ _thread_add_message (notmuch_thread_t *thread,
        tag = notmuch_tags_get (tags);
        g_hash_table_insert (thread->tags, xstrdup (tag), NULL);
     }
+}
+
+static void
+_thread_add_matched_message (notmuch_thread_t *thread,
+                            notmuch_message_t *message)
+{
+    time_t date;
 
     date = notmuch_message_get_date (message);
 
-    if (date < thread->oldest || ! thread->total_messages)
+    if (date < thread->oldest || ! thread->matched_messages)
        thread->oldest = date;
 
-    if (date > thread->newest || ! thread->total_messages)
+    if (date > thread->newest || ! thread->matched_messages)
        thread->newest = date;
 
-    thread->total_messages++;
+    thread->matched_messages++;
+}
+
+static void
+_resolve_thread_relationships (unused (notmuch_thread_t *thread))
+{
+    notmuch_message_node_t **prev, *node;
+    notmuch_message_t *message, *parent;
+    const char *in_reply_to;
+
+    prev = &thread->message_list->head;
+    while ((node = *prev)) {
+       message = node->message;
+       in_reply_to = _notmuch_message_get_in_reply_to (message);
+       if (in_reply_to && strlen (in_reply_to) &&
+           g_hash_table_lookup_extended (thread->message_hash,
+                                         in_reply_to, NULL,
+                                         (void **) &parent))
+       {
+           *prev = node->next;
+           if (thread->message_list->tail == &node->next)
+               thread->message_list->tail = prev;
+           node->next = NULL;
+           _notmuch_message_add_reply (parent, node);
+       } else {
+           prev = &((*prev)->next);
+       }
+    }
+
+    /* XXX: After scanning through the entire list looking for parents
+     * via "In-Reply-To", we should do a second pass that looks at the
+     * list of messages IDs in the "References" header instead. (And
+     * for this the parent would be the "deepest" message of all the
+     * messages found in the "References" list.)
+     *
+     * Doing this will allow messages and sub-threads to be positioned
+     * correctly in the thread even when an intermediate message is
+     * missing from the thread.
+     */
 }
 
 /* Create a new notmuch_thread_t object for the given thread ID,
@@ -152,6 +212,10 @@ _notmuch_thread_create (void *ctx,
     if (unlikely (query_string == NULL))
        return NULL;
 
+    /* XXX: We could be a bit more efficient here if
+     * thread_id_query_string is identical to query_string, (then we
+     * could get by with just one database search instead of two). */
+
     matched_query_string = talloc_asprintf (ctx, "%s AND (%s)",
                                            thread_id_query_string,
                                            query_string);
@@ -181,12 +245,19 @@ _notmuch_thread_create (void *ctx,
     thread->tags = g_hash_table_new_full (g_str_hash, g_str_equal,
                                          free, NULL);
 
+    thread->message_list = _notmuch_message_list_create (thread);
+    if (unlikely (thread->message_list == NULL))
+       return NULL;
+
+    thread->message_hash = g_hash_table_new_full (g_str_hash, g_str_equal,
+                                                 free, NULL);
+
     thread->total_messages = 0;
     thread->matched_messages = 0;
     thread->oldest = 0;
     thread->newest = 0;
 
-    notmuch_query_set_sort (thread_id_query, NOTMUCH_SORT_DATE_OLDEST_FIRST);
+    notmuch_query_set_sort (thread_id_query, NOTMUCH_SORT_DATE);
 
     for (messages = notmuch_query_search_messages (thread_id_query, 0, -1);
         notmuch_messages_has_more (messages);
@@ -201,14 +272,22 @@ _notmuch_thread_create (void *ctx,
         notmuch_messages_has_more (messages);
         notmuch_messages_advance (messages))
     {
-       thread->matched_messages++;
+       _thread_add_matched_message (thread, notmuch_messages_get (messages));
     }
 
     notmuch_query_destroy (matched_query);
 
+    _resolve_thread_relationships (thread);
+
     return thread;
 }
 
+notmuch_messages_t *
+notmuch_thread_get_toplevel_messages (notmuch_thread_t *thread)
+{
+    return _notmuch_messages_create (thread->message_list);
+}
+
 const char *
 notmuch_thread_get_thread_id (notmuch_thread_t *thread)
 {