#include <gmime/gmime.h>
#include <glib.h> /* GHashTable */
-struct _notmuch_thread {
+struct visible _notmuch_thread {
notmuch_database_t *notmuch;
char *thread_id;
char *subject;
char *authors;
GHashTable *tags;
+ /* All messages, oldest first. */
notmuch_message_list_t *message_list;
+ /* Top-level messages, oldest first. */
+ notmuch_message_list_t *toplevel_list;
+
GHashTable *message_hash;
int total_messages;
int matched_messages;
if (comma && strlen(comma) > 1) {
/* let's assemble what we think is the correct name */
lname = comma - author;
- fname = strlen(author) - lname - 2;
- strncpy(clean_author, comma + 2, fname);
+
+ /* Skip all the spaces after the comma */
+ fname = strlen(author) - lname - 1;
+ comma += 1;
+ while (*comma == ' ') {
+ fname -= 1;
+ comma += 1;
+ }
+ strncpy(clean_author, comma, fname);
+
*(clean_author+fname) = ' ';
strncpy(clean_author + fname + 1, author, lname);
*(clean_author+fname+1+lname) = '\0';
*/
static void
_thread_add_message (notmuch_thread_t *thread,
- notmuch_message_t *message)
+ notmuch_message_t *message,
+ notmuch_string_list_t *exclude_terms,
+ notmuch_exclude_t omit_exclude)
{
notmuch_tags_t *tags;
const char *tag;
InternetAddress *address;
const char *from, *author;
char *clean_author;
+ notmuch_bool_t message_excluded = FALSE;
+
+ if (omit_exclude != NOTMUCH_EXCLUDE_FALSE) {
+ for (tags = notmuch_message_get_tags (message);
+ notmuch_tags_valid (tags);
+ notmuch_tags_move_to_next (tags))
+ {
+ tag = notmuch_tags_get (tags);
+ /* Is message excluded? */
+ for (notmuch_string_node_t *term = exclude_terms->head;
+ term != NULL;
+ term = term->next)
+ {
+ /* We ignore initial 'K'. */
+ if (strcmp(tag, (term->string + 1)) == 0) {
+ message_excluded = TRUE;
+ break;
+ }
+ }
+ }
+ }
+
+ if (message_excluded && omit_exclude == NOTMUCH_EXCLUDE_ALL)
+ return;
_notmuch_message_list_add_message (thread->message_list,
talloc_steal (thread, message));
tag = notmuch_tags_get (tags);
g_hash_table_insert (thread->tags, xstrdup (tag), NULL);
}
+
+ /* Mark excluded messages. */
+ if (message_excluded)
+ notmuch_message_set_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED, TRUE);
}
static void
_thread_set_subject_from_message (thread, message);
}
- thread->matched_messages++;
+ if (!notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED))
+ thread->matched_messages++;
if (g_hash_table_lookup_extended (thread->message_hash,
notmuch_message_get_message_id (message), NULL,
}
static void
-_resolve_thread_relationships (unused (notmuch_thread_t *thread))
+_resolve_thread_relationships (notmuch_thread_t *thread)
{
- notmuch_message_node_t **prev, *node;
+ notmuch_message_node_t *node;
notmuch_message_t *message, *parent;
const char *in_reply_to;
- prev = &thread->message_list->head;
- while ((node = *prev)) {
+ for (node = thread->message_list->head; node; node = node->next) {
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);
- }
+ _notmuch_message_add_reply (parent, message);
+ else
+ _notmuch_message_list_add_message (thread->toplevel_list, message);
}
/* XXX: After scanning through the entire list looking for parents
notmuch_database_t *notmuch,
unsigned int seed_doc_id,
notmuch_doc_id_set_t *match_set,
+ notmuch_string_list_t *exclude_terms,
+ notmuch_exclude_t omit_excluded,
notmuch_sort_t sort)
{
- notmuch_thread_t *thread;
+ void *local = talloc_new (ctx);
+ notmuch_thread_t *thread = NULL;
notmuch_message_t *seed_message;
const char *thread_id;
- const char *thread_id_query_string;
+ char *thread_id_query_string;
notmuch_query_t *thread_id_query;
notmuch_messages_t *messages;
notmuch_message_t *message;
- seed_message = _notmuch_message_create (ctx, notmuch, seed_doc_id, NULL);
+ seed_message = _notmuch_message_create (local, notmuch, seed_doc_id, NULL);
if (! seed_message)
INTERNAL_ERROR ("Thread seed message %u does not exist", seed_doc_id);
thread_id = notmuch_message_get_thread_id (seed_message);
- thread_id_query_string = talloc_asprintf (ctx, "thread:%s", thread_id);
+ thread_id_query_string = talloc_asprintf (local, "thread:%s", thread_id);
if (unlikely (thread_id_query_string == NULL))
- return NULL;
+ goto DONE;
- thread_id_query = notmuch_query_create (notmuch, thread_id_query_string);
+ thread_id_query = talloc_steal (
+ local, notmuch_query_create (notmuch, thread_id_query_string));
if (unlikely (thread_id_query == NULL))
- return NULL;
+ goto DONE;
- thread = talloc (ctx, notmuch_thread_t);
+ thread = talloc (local, notmuch_thread_t);
if (unlikely (thread == NULL))
- return NULL;
+ goto DONE;
talloc_set_destructor (thread, _notmuch_thread_destructor);
free, NULL);
thread->message_list = _notmuch_message_list_create (thread);
- if (unlikely (thread->message_list == NULL))
- return NULL;
+ thread->toplevel_list = _notmuch_message_list_create (thread);
+ if (unlikely (thread->message_list == NULL ||
+ thread->toplevel_list == NULL)) {
+ thread = NULL;
+ goto DONE;
+ }
thread->message_hash = g_hash_table_new_full (g_str_hash, g_str_equal,
free, NULL);
if (doc_id == seed_doc_id)
message = seed_message;
- _thread_add_message (thread, message);
+ _thread_add_message (thread, message, exclude_terms, omit_excluded);
if ( _notmuch_doc_id_set_contains (match_set, doc_id)) {
_notmuch_doc_id_set_remove (match_set, doc_id);
_notmuch_message_close (message);
}
- notmuch_query_destroy (thread_id_query);
-
_resolve_thread_authors_string (thread);
_resolve_thread_relationships (thread);
+ /* Commit to returning thread. */
+ talloc_steal (ctx, thread);
+
+ DONE:
+ talloc_free (local);
return thread;
}
notmuch_messages_t *
notmuch_thread_get_toplevel_messages (notmuch_thread_t *thread)
+{
+ return _notmuch_messages_create (thread->toplevel_list);
+}
+
+notmuch_messages_t *
+notmuch_thread_get_messages (notmuch_thread_t *thread)
{
return _notmuch_messages_create (thread->message_list);
}
notmuch_tags_t *
notmuch_thread_get_tags (notmuch_thread_t *thread)
{
- notmuch_tags_t *tags;
+ notmuch_string_list_t *tags;
GList *keys, *l;
- tags = _notmuch_tags_create (thread);
+ tags = _notmuch_string_list_create (thread);
if (unlikely (tags == NULL))
return NULL;
keys = g_hash_table_get_keys (thread->tags);
for (l = keys; l; l = l->next)
- _notmuch_tags_add_tag (tags, (char *) l->data);
+ _notmuch_string_list_append (tags, (char *) l->data);
g_list_free (keys);
- _notmuch_tags_prepare_iterator (tags);
+ _notmuch_string_list_sort (tags);
- return tags;
+ return _notmuch_tags_create (thread, tags);
}
void