diff options
| -rw-r--r-- | TODO | 3 | ||||
| -rw-r--r-- | notmuch.c | 38 | ||||
| -rw-r--r-- | notmuch.h | 123 | ||||
| -rw-r--r-- | query.cc | 112 |
4 files changed, 135 insertions, 141 deletions
@@ -1,6 +1,3 @@ -Rename notmuch_thread_results_t and notmuch_message_results_t to -notmuch_threads_t and notmuch_messages_t respectively. - Add a talloc context as the first argument to each command in notmuch.c. @@ -812,7 +812,7 @@ search_command (int argc, char *argv[]) void *local = talloc_new (NULL); notmuch_database_t *notmuch = NULL; notmuch_query_t *query; - notmuch_thread_results_t *results; + notmuch_threads_t *threads; notmuch_thread_t *thread; notmuch_tags_t *tags; char *query_str; @@ -835,13 +835,13 @@ search_command (int argc, char *argv[]) goto DONE; } - for (results = notmuch_query_search_threads (query); - notmuch_thread_results_has_more (results); - notmuch_thread_results_advance (results)) + for (threads = notmuch_query_search_threads (query); + notmuch_threads_has_more (threads); + notmuch_threads_advance (threads)) { int first = 1; - thread = notmuch_thread_results_get (results); + thread = notmuch_threads_get (threads); date = notmuch_thread_get_oldest_date (thread); relative_date = _format_relative_date (local, date); @@ -903,7 +903,7 @@ show_command (unused (int argc), unused (char *argv[])) char *query_string; notmuch_database_t *notmuch = NULL; notmuch_query_t *query = NULL; - notmuch_message_results_t *messages; + notmuch_messages_t *messages; notmuch_message_t *message; const char *filename; FILE *file; @@ -943,10 +943,10 @@ show_command (unused (int argc), unused (char *argv[])) } for (messages = notmuch_query_search_messages (query); - notmuch_message_results_has_more (messages); - notmuch_message_results_advance (messages)) + notmuch_messages_has_more (messages); + notmuch_messages_advance (messages)) { - message = notmuch_message_results_get (messages); + message = notmuch_messages_get (messages); printf ("%%message{\n"); @@ -1006,7 +1006,7 @@ tag_command (unused (int argc), unused (char *argv[])) char *query_string; notmuch_database_t *notmuch = NULL; notmuch_query_t *query; - notmuch_message_results_t *results; + notmuch_messages_t *messages; notmuch_message_t *message; int ret = 0; int i; @@ -1070,11 +1070,11 @@ tag_command (unused (int argc), unused (char *argv[])) goto DONE; } - for (results = notmuch_query_search_messages (query); - notmuch_message_results_has_more (results); - notmuch_message_results_advance (results)) + for (messages = notmuch_query_search_messages (query); + notmuch_messages_has_more (messages); + notmuch_messages_advance (messages)) { - message = notmuch_message_results_get (results); + message = notmuch_messages_get (messages); notmuch_message_freeze (message); @@ -1107,7 +1107,7 @@ dump_command (int argc, char *argv[]) FILE *output = NULL; notmuch_database_t *notmuch = NULL; notmuch_query_t *query; - notmuch_message_results_t *results; + notmuch_messages_t *messages; notmuch_message_t *message; notmuch_tags_t *tags; int ret = 0; @@ -1139,12 +1139,12 @@ dump_command (int argc, char *argv[]) notmuch_query_set_sort (query, NOTMUCH_SORT_MESSAGE_ID); - for (results = notmuch_query_search_messages (query); - notmuch_message_results_has_more (results); - notmuch_message_results_advance (results)) + for (messages = notmuch_query_search_messages (query); + notmuch_messages_has_more (messages); + notmuch_messages_advance (messages)) { int first = 1; - message = notmuch_message_results_get (results); + message = notmuch_messages_get (messages); fprintf (output, "%s (", notmuch_message_get_message_id (message)); @@ -108,9 +108,9 @@ notmuch_status_to_string (notmuch_status_t status); * notmuch_<foo> functions below. */ typedef struct _notmuch_database notmuch_database_t; typedef struct _notmuch_query notmuch_query_t; -typedef struct _notmuch_thread_results notmuch_thread_results_t; +typedef struct _notmuch_threads notmuch_threads_t; typedef struct _notmuch_thread notmuch_thread_t; -typedef struct _notmuch_message_results notmuch_message_results_t; +typedef struct _notmuch_messages notmuch_messages_t; typedef struct _notmuch_message notmuch_message_t; typedef struct _notmuch_tags notmuch_tags_t; @@ -331,24 +331,24 @@ typedef enum { void notmuch_query_set_sort (notmuch_query_t *query, notmuch_sort_t sort); -/* Execute a query for threads, returning a notmuch_thread_results_t - * object which can be used to iterate over the results. The results +/* Execute a query for threads, returning a notmuch_threads_t object + * which can be used to iterate over the results. The returned threads * object is owned by the query and as such, will only be valid until * notmuch_query_destroy. * * Typical usage might be: * * notmuch_query_t *query; - * notmuch_thread_results_t *results; + * notmuch_threads_t *threads; * notmuch_thread_t *thread; * * query = notmuch_query_create (database, query_string); * - * for (results = notmuch_query_search_threads (query); - * notmuch_thread_results_has_more (results); - * notmuch_thread_results_advance (results)) + * for (threads = notmuch_query_search_threads (query); + * notmuch_threads_has_more (threads); + * notmuch_threads_advance (threads)) * { - * thread = notmuch_thread_results_get (results); + * thread = notmuch_threads_get (threads); * .... * notmuch_thread_destroy (thread); * } @@ -363,31 +363,31 @@ notmuch_query_set_sort (notmuch_query_t *query, notmuch_sort_t sort); * destroyed. * * Note that there's no explicit destructor needed for the - * notmuch_thread_results_t object. (For consistency, we do provide a - * notmuch_thread_results_destroy function, but there's no good reason + * notmuch_threads_t object. (For consistency, we do provide a + * notmuch_threads_destroy function, but there's no good reason * to call it if the query is about to be destroyed). */ -notmuch_thread_results_t * +notmuch_threads_t * notmuch_query_search_threads (notmuch_query_t *query); -/* Execute a query for messages, returning a notmuch_message_results_t - * object which can be used to iterate over the results. The results - * object is owned by the query and as such, will only be valid until - * notmuch_query_destroy. +/* Execute a query for messages, returning a notmuch_messages_t object + * which can be used to iterate over the results. The returned + * messages object is owned by the query and as such, will only be + * valid until notmuch_query_destroy. * * Typical usage might be: * * notmuch_query_t *query; - * notmuch_message_results_t *results; + * notmuch_messages_t *messages; * notmuch_message_t *message; * * query = notmuch_query_create (database, query_string); * - * for (results = notmuch_query_search_messages (query); - * notmuch_message_results_has_more (results); - * notmuch_message_results_advance (results)) + * for (messages = notmuch_query_search_messages (query); + * notmuch_messages_has_more (messages); + * notmuch_messages_advance (messages)) * { - * message = notmuch_message_results_get (results); + * message = notmuch_messages_get (messages); * .... * notmuch_message_destroy (message); * } @@ -402,17 +402,17 @@ notmuch_query_search_threads (notmuch_query_t *query); * when the query is destroyed. * * Note that there's no explicit destructor needed for the - * notmuch_message_results_t object. (For consistency, we do provide a - * notmuch_message_results_destroy function, but there's no good + * notmuch_messages_t object. (For consistency, we do provide a + * notmuch_messages_destroy function, but there's no good * reason to call it if the query is about to be destroyed). */ -notmuch_message_results_t * +notmuch_messages_t * notmuch_query_search_messages (notmuch_query_t *query); /* Destroy a notmuch_query_t along with any associated resources. * - * This will in turn destroy any notmuch_thread_results_t and - * notmuch_message_results_t objects generated by this query, (and in + * This will in turn destroy any notmuch_threads_t and + * notmuch_messages_t objects generated by this query, (and in * turn any notmuch_thrad_t and notmuch_message_t objects generated * from those results, etc.), if such objects haven't already been * destroyed. @@ -420,49 +420,49 @@ notmuch_query_search_messages (notmuch_query_t *query); void notmuch_query_destroy (notmuch_query_t *query); -/* Does the given notmuch_thread_results_t object contain any more +/* Does the given notmuch_threads_t object contain any more * results. * - * When this function returns TRUE, notmuch_thread_results_get will + * When this function returns TRUE, notmuch_threads_get will * return a valid object. Whereas when this function returns FALSE, - * notmuch_thread_results_get will return NULL. + * notmuch_threads_get will return NULL. * * See the documentation of notmuch_query_search_threads for example - * code showing how to iterate over a notmuch_thread_results_t object. + * code showing how to iterate over a notmuch_threads_t object. */ notmuch_bool_t -notmuch_thread_results_has_more (notmuch_thread_results_t *results); +notmuch_threads_has_more (notmuch_threads_t *threads); -/* Get the current result from 'results' as a notmuch_thread_t. +/* Get the current thread from 'threads' as a notmuch_thread_t. * - * Note: The returned thread belongs to 'results' and has a lifetime + * Note: The returned thread belongs to 'threads' and has a lifetime * identical to it (and the query to which it belongs). * * See the documentation of notmuch_query_search_threads for example - * code showing how to iterate over a notmuch_thread_results_t object. + * code showing how to iterate over a notmuch_threads_t object. * * If an out-of-memory situation occurs, this function will return * NULL. */ notmuch_thread_t * -notmuch_thread_results_get (notmuch_thread_results_t *results); +notmuch_threads_get (notmuch_threads_t *threads); -/* Advance the 'results' iterator to the next result. +/* Advance the 'threads' iterator to the next thread. * * See the documentation of notmuch_query_search_threads for example - * code showing how to iterate over a notmuch_thread_results_t object. + * code showing how to iterate over a notmuch_threads_t object. */ void -notmuch_thread_results_advance (notmuch_thread_results_t *results); +notmuch_threads_advance (notmuch_threads_t *threads); -/* Destroy a notmuch_thread_results_t object. +/* Destroy a notmuch_threads_t object. * * It's not strictly necessary to call this function. All memory from - * the notmuch_thread_results_t object will be reclaimed when the + * the notmuch_threads_t object will be reclaimed when the * containg query object is destroyed. */ void -notmuch_thread_results_destroy (notmuch_thread_results_t *results); +notmuch_threads_destroy (notmuch_threads_t *threads); /* Get the thread ID of 'thread'. * @@ -517,7 +517,7 @@ notmuch_thread_get_newest_date (notmuch_thread_t *thread); * notmuch_tags_t *tags; * const char *tag; * - * thread = notmuch_thread_results_get (thread_results); + * thread = notmuch_threads_get (threads); * * for (tags = notmuch_thread_get_tags (thread); * notmuch_tags_has_more (tags); @@ -541,52 +541,49 @@ notmuch_thread_get_tags (notmuch_thread_t *thread); void notmuch_thread_destroy (notmuch_thread_t *thread); -/* Does the given notmuch_message_results_t object contain any more - * results. +/* Does the given notmuch_messages_t object contain any more + * messages. * - * When this function returns TRUE, notmuch_message_results_get will - * return a valid object. Whereas when this function returns FALSE, - * notmuch_message_results_get will return NULL. + * When this function returns TRUE, notmuch_messages_get will return a + * valid object. Whereas when this function returns FALSE, + * notmuch_messages_get will return NULL. * * See the documentation of notmuch_query_search_messages for example - * code showing how to iterate over a notmuch_message_results_t - * object. + * code showing how to iterate over a notmuch_messages_t object. */ notmuch_bool_t -notmuch_message_results_has_more (notmuch_message_results_t *results); +notmuch_messages_has_more (notmuch_messages_t *messages); -/* Get the current result from 'results' as a notmuch_message_t. +/* Get the current message from 'messages' as a notmuch_message_t. * - * Note: The returned message belongs to 'results' and has a lifetime + * Note: The returned message belongs to 'messages' and has a lifetime * identical to it (and the query to which it belongs). * * See the documentation of notmuch_query_search_messages for example - * code showing how to iterate over a notmuch_message_results_t - * object. + * code showing how to iterate over a notmuch_messages_t object. * * If an out-of-memory situation occurs, this function will return * NULL. */ notmuch_message_t * -notmuch_message_results_get (notmuch_message_results_t *results); +notmuch_messages_get (notmuch_messages_t *messages); -/* Advance the 'results' iterator to the next result. +/* Advance the 'messages' iterator to the next result. * * See the documentation of notmuch_query_search_messages for example - * code showing how to iterate over a notmuch_message_results_t - * object. + * code showing how to iterate over a notmuch_messages_t object. */ void -notmuch_message_results_advance (notmuch_message_results_t *results); +notmuch_messages_advance (notmuch_messages_t *messages); -/* Destroy a notmuch_message_results_t object. +/* Destroy a notmuch_messages_t object. * * It's not strictly necessary to call this function. All memory from - * the notmuch_message_results_t object will be reclaimed when the - * containg query object is destroyed. + * the notmuch_messages_t object will be reclaimed when the containg + * query object is destroyed. */ void -notmuch_message_results_destroy (notmuch_message_results_t *results); +notmuch_messages_destroy (notmuch_messages_t *messages); /* Get the message ID of 'message'. * @@ -31,13 +31,13 @@ struct _notmuch_query { notmuch_sort_t sort; }; -struct _notmuch_message_results { +struct _notmuch_messages { notmuch_database_t *notmuch; Xapian::MSetIterator iterator; Xapian::MSetIterator iterator_end; }; -struct _notmuch_thread_results { +struct _notmuch_threads { notmuch_database_t *notmuch; GPtrArray *threads; unsigned int index; @@ -79,23 +79,23 @@ notmuch_query_set_sort (notmuch_query_t *query, notmuch_sort_t sort) * talloc_set_destructor at all otherwise). */ static int -_notmuch_message_results_destructor (notmuch_message_results_t *results) +_notmuch_messages_destructor (notmuch_messages_t *messages) { - results->iterator.~MSetIterator (); - results->iterator_end.~MSetIterator (); + messages->iterator.~MSetIterator (); + messages->iterator_end.~MSetIterator (); return 0; } -notmuch_message_results_t * +notmuch_messages_t * notmuch_query_search_messages (notmuch_query_t *query) { notmuch_database_t *notmuch = query->notmuch; const char *query_string = query->query_string; - notmuch_message_results_t *results; + notmuch_messages_t *messages; - results = talloc (query, notmuch_message_results_t); - if (unlikely (results == NULL)) + messages = talloc (query, notmuch_messages_t); + if (unlikely (messages == NULL)) return NULL; try { @@ -140,64 +140,64 @@ notmuch_query_search_messages (notmuch_query_t *query) mset = enquire.get_mset (0, notmuch->xapian_db->get_doccount ()); - results->notmuch = notmuch; + messages->notmuch = notmuch; - new (&results->iterator) Xapian::MSetIterator (); - new (&results->iterator_end) Xapian::MSetIterator (); + new (&messages->iterator) Xapian::MSetIterator (); + new (&messages->iterator_end) Xapian::MSetIterator (); - talloc_set_destructor (results, _notmuch_message_results_destructor); + talloc_set_destructor (messages, _notmuch_messages_destructor); - results->iterator = mset.begin (); - results->iterator_end = mset.end (); + messages->iterator = mset.begin (); + messages->iterator_end = mset.end (); } catch (const Xapian::Error &error) { fprintf (stderr, "A Xapian exception occurred: %s\n", error.get_msg().c_str()); } - return results; + return messages; } /* Glib objects force use to use a talloc destructor as well, (but not - * nearly as ugly as the for message_results due to C++ objects). At + * nearly as ugly as the for messages due to C++ objects). At * this point, I'd really like to have some talloc-friendly * equivalents for the few pieces of glib that I'm using. */ static int -_notmuch_thread_results_destructor (notmuch_thread_results_t *results) +_notmuch_threads_destructor (notmuch_threads_t *threads) { - g_ptr_array_free (results->threads, TRUE); + g_ptr_array_free (threads->threads, TRUE); return 0; } -notmuch_thread_results_t * +notmuch_threads_t * notmuch_query_search_threads (notmuch_query_t *query) { - notmuch_thread_results_t *thread_results; + notmuch_threads_t *threads; notmuch_thread_t *thread; const char *thread_id; - notmuch_message_results_t *message_results; + notmuch_messages_t *messages; notmuch_message_t *message; GHashTable *seen; - thread_results = talloc (query, notmuch_thread_results_t); - if (thread_results == NULL) + threads = talloc (query, notmuch_threads_t); + if (threads == NULL) return NULL; - thread_results->notmuch = query->notmuch; - thread_results->threads = g_ptr_array_new (); - thread_results->index = 0; + threads->notmuch = query->notmuch; + threads->threads = g_ptr_array_new (); + threads->index = 0; - talloc_set_destructor (thread_results, _notmuch_thread_results_destructor); + talloc_set_destructor (threads, _notmuch_threads_destructor); seen = g_hash_table_new_full (g_str_hash, g_str_equal, free, NULL); - for (message_results = notmuch_query_search_messages (query); - notmuch_message_results_has_more (message_results); - notmuch_message_results_advance (message_results)) + for (messages = notmuch_query_search_messages (query); + notmuch_messages_has_more (messages); + notmuch_messages_advance (messages)) { - message = notmuch_message_results_get (message_results); + message = notmuch_messages_get (messages); thread_id = notmuch_message_get_thread_id (message); @@ -210,7 +210,7 @@ notmuch_query_search_threads (notmuch_query_t *query) g_hash_table_insert (seen, xstrdup (thread_id), thread); - g_ptr_array_add (thread_results->threads, thread); + g_ptr_array_add (threads->threads, thread); } _notmuch_thread_add_message (thread, message); @@ -220,7 +220,7 @@ notmuch_query_search_threads (notmuch_query_t *query) g_hash_table_unref (seen); - return thread_results; + return threads; } void @@ -230,72 +230,72 @@ notmuch_query_destroy (notmuch_query_t *query) } notmuch_bool_t -notmuch_message_results_has_more (notmuch_message_results_t *results) +notmuch_messages_has_more (notmuch_messages_t *messages) { - return (results->iterator != results->iterator_end); + return (messages->iterator != messages->iterator_end); } notmuch_message_t * -notmuch_message_results_get (notmuch_message_results_t *results) +notmuch_messages_get (notmuch_messages_t *messages) { notmuch_message_t *message; Xapian::docid doc_id; notmuch_private_status_t status; - if (! notmuch_message_results_has_more (results)) + if (! notmuch_messages_has_more (messages)) return NULL; - doc_id = *results->iterator; + doc_id = *messages->iterator; - message = _notmuch_message_create (results, - results->notmuch, doc_id, + message = _notmuch_message_create (messages, + messages->notmuch, doc_id, &status); if (message == NULL && status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) { - INTERNAL_ERROR ("a results iterator contains a non-existent document ID.\n"); + INTERNAL_ERROR ("a messages iterator contains a non-existent document ID.\n"); } return message; } void -notmuch_message_results_advance (notmuch_message_results_t *results) +notmuch_messages_advance (notmuch_messages_t *messages) { - results->iterator++; + messages->iterator++; } void -notmuch_message_results_destroy (notmuch_message_results_t *results) +notmuch_messages_destroy (notmuch_messages_t *messages) { - talloc_free (results); + talloc_free (messages); } notmuch_bool_t -notmuch_thread_results_has_more (notmuch_thread_results_t *results) +notmuch_threads_has_more (notmuch_threads_t *threads) { - return (results->index < results->threads->len); + return (threads->index < threads->threads->len); } notmuch_thread_t * -notmuch_thread_results_get (notmuch_thread_results_t *results) +notmuch_threads_get (notmuch_threads_t *threads) { - if (! notmuch_thread_results_has_more (results)) + if (! notmuch_threads_has_more (threads)) return NULL; - return (notmuch_thread_t *) g_ptr_array_index (results->threads, - results->index); + return (notmuch_thread_t *) g_ptr_array_index (threads->threads, + threads->index); } void -notmuch_thread_results_advance (notmuch_thread_results_t *results) +notmuch_threads_advance (notmuch_threads_t *threads) { - results->index++; + threads->index++; } void -notmuch_thread_results_destroy (notmuch_thread_results_t *results) +notmuch_threads_destroy (notmuch_threads_t *threads) { - talloc_free (results); + talloc_free (threads); } |