From cd467cafb5eee180661ebc14e0fb71426e67c855 Mon Sep 17 00:00:00 2001 From: Carl Worth Date: Sun, 25 Oct 2009 22:11:09 -0700 Subject: [PATCH] Rename notmuch_query_search to notmuch_query_search_messages Along with renaming notmuch_results_t to notmuch_message_results_t. The new type is quite a mouthful, but I don't expect it to be used much other than the for-loop idiom in the documentation, (which does at least fit nicely within 80 columns). This is all in preparation for the addition of a new notmuch_query_search_threads of course. --- notmuch.c | 20 ++++++++-------- notmuch.h | 69 +++++++++++++++++++++++++++++-------------------------- query.cc | 22 +++++++++--------- 3 files changed, 58 insertions(+), 53 deletions(-) diff --git a/notmuch.c b/notmuch.c index fbd773d7..47969e1f 100644 --- a/notmuch.c +++ b/notmuch.c @@ -608,7 +608,7 @@ search_command (int argc, char *argv[]) void *local = talloc_new (NULL); notmuch_database_t *notmuch = NULL; notmuch_query_t *query; - notmuch_results_t *results; + notmuch_message_results_t *results; notmuch_message_t *message; notmuch_tags_t *tags; char *query_str; @@ -638,12 +638,12 @@ search_command (int argc, char *argv[]) goto DONE; } - for (results = notmuch_query_search (query); - notmuch_results_has_more (results); - notmuch_results_advance (results)) + for (results = notmuch_query_search_messages (query); + notmuch_message_results_has_more (results); + notmuch_message_results_advance (results)) { int first = 1; - message = notmuch_results_get (results); + message = notmuch_message_results_get (results); printf ("%s (", notmuch_message_get_message_id (message)); @@ -687,7 +687,7 @@ dump_command (int argc, char *argv[]) FILE *output; notmuch_database_t *notmuch = NULL; notmuch_query_t *query; - notmuch_results_t *results; + notmuch_message_results_t *results; notmuch_message_t *message; notmuch_tags_t *tags; int ret = 0; @@ -719,12 +719,12 @@ dump_command (int argc, char *argv[]) notmuch_query_set_sort (query, NOTMUCH_SORT_MESSAGE_ID); - for (results = notmuch_query_search (query); - notmuch_results_has_more (results); - notmuch_results_advance (results)) + for (results = notmuch_query_search_messages (query); + notmuch_message_results_has_more (results); + notmuch_message_results_advance (results)) { int first = 1; - message = notmuch_results_get (results); + message = notmuch_message_results_get (results); fprintf (output, "%s (", notmuch_message_get_message_id (message)); diff --git a/notmuch.h b/notmuch.h index a6f3f5d4..d383e7d8 100644 --- a/notmuch.h +++ b/notmuch.h @@ -102,7 +102,7 @@ notmuch_status_to_string (notmuch_status_t status); * notmuch_ functions below. */ typedef struct _notmuch_database notmuch_database_t; typedef struct _notmuch_query notmuch_query_t; -typedef struct _notmuch_results notmuch_results_t; +typedef struct _notmuch_message_results notmuch_message_results_t; typedef struct _notmuch_message notmuch_message_t; typedef struct _notmuch_tags notmuch_tags_t; @@ -313,22 +313,24 @@ typedef enum { void notmuch_query_set_sort (notmuch_query_t *query, notmuch_sort_t sort); -/* Execute a query, returning a notmuch_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_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. * * Typical usage might be: * * notmuch_query_t *query; - * notmuch_results_t *results; + * notmuch_message_results_t *results; + * notmuch_message_t *message; * * query = notmuch_query_create (database, query_string); * - * for (results = notmuch_query_search (query); - * notmuch_results_has_more (results); - * notmuch_result_advance (results)) + * for (results = notmuch_query_search_messages (query); + * notmuch_message_results_has_more (results); + * notmuch_message_results_advance (results)) * { - * message = notmuch_results_get (results); + * message = notmuch_message_results_get (results); * .... * notmuch_message_destroy (message); * } @@ -343,12 +345,12 @@ notmuch_query_set_sort (notmuch_query_t *query, notmuch_sort_t sort); * when the query is destroyed. * * Note that there's no explicit destructor needed for the - * notmuch_results_t object. (For consistency, we do provide a - * notmuch_results_destroy function, but there's no good reason to - * call it if the query is about to be destroyed). + * notmuch_message_results_t object. (For consistency, we do provide a + * notmuch_message_results_destroy function, but there's no good + * reason to call it if the query is about to be destroyed). */ -notmuch_results_t * -notmuch_query_search (notmuch_query_t *query); +notmuch_message_results_t * +notmuch_query_search_messages (notmuch_query_t *query); /* Destroy a notmuch_query_t along with any associated resources. * @@ -359,48 +361,52 @@ notmuch_query_search (notmuch_query_t *query); void notmuch_query_destroy (notmuch_query_t *query); -/* Does the given notmuch_results_t object contain any more results. +/* Does the given notmuch_message_results_t object contain any more + * results. * - * When this function returns TRUE, notmuch_results_get will return a - * valid object. Whereas when this function returns FALSE, - * notmuch_results_get will return NULL. + * 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. * - * See the documentation of notmuch_query_search for example code - * showing how to iterate over a notmuch_results_t object. + * See the documentation of notmuch_query_search_messages for example + * code showing how to iterate over a notmuch_message_results_t + * object. */ notmuch_bool_t -notmuch_results_has_more (notmuch_results_t *results); +notmuch_message_results_has_more (notmuch_message_results_t *results); /* Get the current result from 'results' as a notmuch_message_t. * * Note: The returned message belongs to 'results' and has a lifetime * identical to it (and the query to which it belongs). * - * See the documentation of notmuch_query_search for example code - * showing how to iterate over a notmuch_results_t object. + * See the documentation of notmuch_query_search_messages for example + * code showing how to iterate over a notmuch_message_results_t + * object. * * If an out-of-memory situation occurs, this function will return * NULL. */ notmuch_message_t * -notmuch_results_get (notmuch_results_t *results); +notmuch_message_results_get (notmuch_message_results_t *results); /* Advance the 'results' iterator to the next result. * - * See the documentation of notmuch_query_search for example code - * showing how to iterate over a notmuch_results_t object. + * See the documentation of notmuch_query_search_messages for example + * code showing how to iterate over a notmuch_message_results_t + * object. */ void -notmuch_results_advance (notmuch_results_t *results); +notmuch_message_results_advance (notmuch_message_results_t *results); -/* Destroy a notmuch_results_t object. +/* Destroy a notmuch_message_results_t object. * * It's not strictly necessary to call this function. All memory from - * the notmuch_results_t object will be reclaimed when the containg - * query object is destroyed. + * the notmuch_message_results_t object will be reclaimed when the + * containg query object is destroyed. */ void -notmuch_results_destroy (notmuch_results_t *results); +notmuch_message_results_destroy (notmuch_message_results_t *results); /* Get the message ID of 'message'. * @@ -416,7 +422,6 @@ notmuch_results_destroy (notmuch_results_t *results); const char * notmuch_message_get_message_id (notmuch_message_t *message); - /* Get the thread ID of 'message'. * * The returned string belongs to 'message' and as such, should not be diff --git a/query.cc b/query.cc index 88d76ef1..c153dad9 100644 --- a/query.cc +++ b/query.cc @@ -29,7 +29,7 @@ struct _notmuch_query { notmuch_sort_t sort; }; -struct _notmuch_results { +struct _notmuch_message_results { notmuch_database_t *notmuch; Xapian::MSetIterator iterator; Xapian::MSetIterator iterator_end; @@ -71,7 +71,7 @@ notmuch_query_set_sort (notmuch_query_t *query, notmuch_sort_t sort) * talloc_set_destructor at all otherwise). */ static int -_notmuch_results_destructor (notmuch_results_t *results) +_notmuch_message_results_destructor (notmuch_message_results_t *results) { results->iterator.~MSetIterator (); results->iterator_end.~MSetIterator (); @@ -79,14 +79,14 @@ _notmuch_results_destructor (notmuch_results_t *results) return 0; } -notmuch_results_t * -notmuch_query_search (notmuch_query_t *query) +notmuch_message_results_t * +notmuch_query_search_messages (notmuch_query_t *query) { notmuch_database_t *notmuch = query->notmuch; const char *query_string = query->query_string; - notmuch_results_t *results; + notmuch_message_results_t *results; - results = talloc (query, notmuch_results_t); + results = talloc (query, notmuch_message_results_t); if (unlikely (results == NULL)) return NULL; @@ -137,7 +137,7 @@ notmuch_query_search (notmuch_query_t *query) new (&results->iterator) Xapian::MSetIterator (); new (&results->iterator_end) Xapian::MSetIterator (); - talloc_set_destructor (results, _notmuch_results_destructor); + talloc_set_destructor (results, _notmuch_message_results_destructor); results->iterator = mset.begin (); results->iterator_end = mset.end (); @@ -157,13 +157,13 @@ notmuch_query_destroy (notmuch_query_t *query) } notmuch_bool_t -notmuch_results_has_more (notmuch_results_t *results) +notmuch_message_results_has_more (notmuch_message_results_t *results) { return (results->iterator != results->iterator_end); } notmuch_message_t * -notmuch_results_get (notmuch_results_t *results) +notmuch_message_results_get (notmuch_message_results_t *results) { notmuch_message_t *message; Xapian::docid doc_id; @@ -185,13 +185,13 @@ notmuch_results_get (notmuch_results_t *results) } void -notmuch_results_advance (notmuch_results_t *results) +notmuch_message_results_advance (notmuch_message_results_t *results) { results->iterator++; } void -notmuch_results_destroy (notmuch_results_t *results) +notmuch_message_results_destroy (notmuch_message_results_t *results) { talloc_free (results); } -- 2.43.0