X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=lib%2Fnotmuch.h;h=9a19699956dc0a9178d6f0fc39110e0ee7acf92d;hp=d03373044a2b800e6ac03d7922cd1355c8ebe75e;hb=f6cb896bc4c0bafca1acd5ac3fb45169cd893e29;hpb=f93b7218c3e2d11c5b3cdd4c367a42ca7a7ede77 diff --git a/lib/notmuch.h b/lib/notmuch.h index d0337304..9a196999 100644 --- a/lib/notmuch.h +++ b/lib/notmuch.h @@ -57,8 +57,8 @@ typedef int notmuch_bool_t; * value. Instead we should map to things like DATABASE_LOCKED or * whatever. * - * NOTMUCH_STATUS_READONLY_DATABASE: An attempt was made to write to a - * database opened in read-only mode. + * NOTMUCH_STATUS_READ_ONLY_DATABASE: An attempt was made to write to + * a database opened in read-only mode. * * NOTMUCH_STATUS_XAPIAN_EXCEPTION: A Xapian exception occurred * @@ -89,7 +89,7 @@ typedef int notmuch_bool_t; typedef enum _notmuch_status { NOTMUCH_STATUS_SUCCESS = 0, NOTMUCH_STATUS_OUT_OF_MEMORY, - NOTMUCH_STATUS_READONLY_DATABASE, + NOTMUCH_STATUS_READ_ONLY_DATABASE, NOTMUCH_STATUS_XAPIAN_EXCEPTION, NOTMUCH_STATUS_FILE_ERROR, NOTMUCH_STATUS_FILE_NOT_EMAIL, @@ -156,7 +156,7 @@ typedef enum { * (not necessarily by this process), by calling * notmuch_database_create with 'path'. By default the database should be * opened for reading only. In order to write to the database you need to - * pass the NOTMUCH_DATABASE_MODE_WRITABLE mode. + * pass the NOTMUCH_DATABASE_MODE_READ_WRITE mode. * * An existing notmuch database can be identified by the presence of a * directory named ".notmuch" below 'path'. @@ -183,15 +183,44 @@ notmuch_database_close (notmuch_database_t *database); const char * notmuch_database_get_path (notmuch_database_t *database); +/* Return the database format version of the given database. */ +unsigned int +notmuch_database_get_version (notmuch_database_t *database); + +/* Does this database need to be upgraded before writing to it? + * + * If this function returns TRUE then no functions that modify the + * database (notmuch_database_add_message, notmuch_message_add_tag, + * notmuch_directory_set_mtime, etc.) will work unless the function + * notmuch_database_upgrade is called successfully first. */ +notmuch_bool_t +notmuch_database_needs_upgrade (notmuch_database_t *database); + +/* Upgrade the current database. + * + * After opening a database in read-write mode, the client should + * check if an upgrade is needed (notmuch_database_needs_upgrade) and + * if so, upgrade with this function before making any modifications. + * + * The optional progress_notify callback can be used by the caller to + * provide progress indication to the user. If non-NULL it will be + * called periodically with 'progress' as a floating-point value in + * the range of [0.0 .. 1.0] indicating the progress made so far in + * the upgrade process. + */ +notmuch_status_t +notmuch_database_upgrade (notmuch_database_t *database, + void (*progress_notify) (void *closure, + double progress), + void *closure); + /* Retrieve a directory object from the database for 'path'. * * Here, 'path' should be a path relative to the path of 'database' * (see notmuch_database_get_path), or else should be an absolute path * with initial components that match the path of 'database'. * - * Note: The resulting notmuch_directory_t object will represent the - * state as it currently exists in the database, (and will not reflect - * subsequent changes). + * Can return NULL if a Xapian exception occurs. */ notmuch_directory_t * notmuch_database_get_directory (notmuch_database_t *database, @@ -219,9 +248,13 @@ notmuch_database_get_directory (notmuch_database_t *database, * * NOTMUCH_STATUS_SUCCESS: Message successfully added to database. * + * NOTMUCH_STATUS_XAPIAN_EXCEPTION: A Xapian exception occurred, + * message not added. + * * NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID: Message has the same message - * ID as another message already in the database. The new filename - * was successfully added to the message in the database. + * ID as another message already in the database. The new + * filename was successfully added to the message in the database + * (if not already present). * * NOTMUCH_STATUS_FILE_ERROR: an error occurred trying to open the * file, (such as permission denied, or file not found, @@ -230,7 +263,7 @@ notmuch_database_get_directory (notmuch_database_t *database, * NOTMUCH_STATUS_FILE_NOT_EMAIL: the contents of filename don't look * like an email message. Nothing added to the database. * - * NOTMUCH_STATUS_READONLY_DATABASE: Database was opened in read-only + * NOTMUCH_STATUS_READ_ONLY_DATABASE: Database was opened in read-only * mode so no message can be added. */ notmuch_status_t @@ -252,11 +285,14 @@ notmuch_database_add_message (notmuch_database_t *database, * NOTMUCH_STATUS_SUCCESS: The last filename was removed and the * message was removed from the database. * + * NOTMUCH_STATUS_XAPIAN_EXCEPTION: A Xapian exception occurred, + * message not removed. + * * NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID: This filename was removed but * the message persists in the database with at least one other * filename. * - * NOTMUCH_STATUS_READONLY_DATABASE: Database was opened in read-only + * NOTMUCH_STATUS_READ_ONLY_DATABASE: Database was opened in read-only * mode so no message can be removed. */ notmuch_status_t @@ -269,8 +305,11 @@ notmuch_database_remove_message (notmuch_database_t *database, * a new notmuch_message_t object is returned. The caller should call * notmuch_message_destroy when done with the message. * - * If no message is found with the given message_id or if an - * out-of-memory situation occurs, this function returns NULL. + * This function returns NULL in the following situations: + * + * * No message is found with the given message_id + * * An out-of-memory situation occurs + * * A Xapian exception occurs */ notmuch_message_t * notmuch_database_find_message (notmuch_database_t *database, @@ -297,11 +336,13 @@ notmuch_database_get_all_tags (notmuch_database_t *db); * * http://xapian.org/docs/queryparser.html * - * As a special case, passing a length-zero string, (that is ""), will + * As a special case, passing either a length-zero string, (that is ""), + * or a string consisting of a single asterisk (that is "*"), will * result in a query that returns all messages in the database. * - * See notmuch_query_set_sort for controlling the order of results and - * notmuch_query_search to actually execute the query. + * See notmuch_query_set_sort for controlling the order of results. + * See notmuch_query_search_messages and notmuch_query_search_threads + * to actually execute the query. * * User should call notmuch_query_destroy when finished with this * query. @@ -316,7 +357,8 @@ notmuch_query_create (notmuch_database_t *database, typedef enum { NOTMUCH_SORT_OLDEST_FIRST, NOTMUCH_SORT_NEWEST_FIRST, - NOTMUCH_SORT_MESSAGE_ID + NOTMUCH_SORT_MESSAGE_ID, + NOTMUCH_SORT_UNSORTED } notmuch_sort_t; /* Specify the sorting desired for this query. */ @@ -337,8 +379,8 @@ notmuch_query_set_sort (notmuch_query_t *query, notmuch_sort_t sort); * query = notmuch_query_create (database, query_string); * * for (threads = notmuch_query_search_threads (query); - * notmuch_threads_has_more (threads); - * notmuch_threads_advance (threads)) + * notmuch_threads_valid (threads); + * notmuch_threads_move_to_next (threads)) * { * thread = notmuch_threads_get (threads); * .... @@ -358,6 +400,8 @@ notmuch_query_set_sort (notmuch_query_t *query, notmuch_sort_t sort); * 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). + * + * If a Xapian exception occurs this function will return NULL. */ notmuch_threads_t * notmuch_query_search_threads (notmuch_query_t *query); @@ -376,8 +420,8 @@ notmuch_query_search_threads (notmuch_query_t *query); * query = notmuch_query_create (database, query_string); * * for (messages = notmuch_query_search_messages (query); - * notmuch_messages_has_more (messages); - * notmuch_messages_advance (messages)) + * notmuch_messages_valid (messages); + * notmuch_messages_move_to_next (messages)) * { * message = notmuch_messages_get (messages); * .... @@ -397,6 +441,8 @@ notmuch_query_search_threads (notmuch_query_t *query); * 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). + * + * If a Xapian exception occurs this function will return NULL. */ notmuch_messages_t * notmuch_query_search_messages (notmuch_query_t *query); @@ -405,25 +451,24 @@ notmuch_query_search_messages (notmuch_query_t *query); * * 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 + * turn any notmuch_thread_t and notmuch_message_t objects generated * from those results, etc.), if such objects haven't already been * destroyed. */ void notmuch_query_destroy (notmuch_query_t *query); -/* Does the given notmuch_threads_t object contain any more - * results. +/* Is the given 'threads' iterator pointing at a valid thread. * - * When this function returns TRUE, notmuch_threads_get will - * return a valid object. Whereas when this function returns FALSE, + * When this function returns TRUE, notmuch_threads_get will return a + * valid object. Whereas when this function returns FALSE, * notmuch_threads_get will return NULL. * * See the documentation of notmuch_query_search_threads for example * code showing how to iterate over a notmuch_threads_t object. */ notmuch_bool_t -notmuch_threads_has_more (notmuch_threads_t *threads); +notmuch_threads_valid (notmuch_threads_t *threads); /* Get the current thread from 'threads' as a notmuch_thread_t. * @@ -439,13 +484,18 @@ notmuch_threads_has_more (notmuch_threads_t *threads); notmuch_thread_t * notmuch_threads_get (notmuch_threads_t *threads); -/* Advance the 'threads' iterator to the next thread. +/* Move the 'threads' iterator to the next thread. + * + * If 'threads' is already pointing at the last thread then the + * iterator will be moved to a point just beyond that last thread, + * (where notmuch_threads_valid will return FALSE and + * notmuch_threads_get will return NULL). * * See the documentation of notmuch_query_search_threads for example * code showing how to iterate over a notmuch_threads_t object. */ void -notmuch_threads_advance (notmuch_threads_t *threads); +notmuch_threads_move_to_next (notmuch_threads_t *threads); /* Destroy a notmuch_threads_t object. * @@ -460,6 +510,9 @@ notmuch_threads_destroy (notmuch_threads_t *threads); * * This function performs a search and returns Xapian's best * guess as to number of matching messages. + * + * If a Xapian exception occurs, this function may return 0 (after + * printing a message). */ unsigned notmuch_query_count_messages (notmuch_query_t *query); @@ -539,7 +592,7 @@ notmuch_thread_get_subject (notmuch_thread_t *thread); time_t notmuch_thread_get_oldest_date (notmuch_thread_t *thread); -/* Get the date of the oldest message in 'thread' as a time_t value. +/* Get the date of the newest message in 'thread' as a time_t value. */ time_t notmuch_thread_get_newest_date (notmuch_thread_t *thread); @@ -566,8 +619,8 @@ notmuch_thread_get_newest_date (notmuch_thread_t *thread); * thread = notmuch_threads_get (threads); * * for (tags = notmuch_thread_get_tags (thread); - * notmuch_tags_has_more (tags); - * notmuch_result_advance (tags)) + * notmuch_tags_valid (tags); + * notmuch_result_move_to_next (tags)) * { * tag = notmuch_tags_get (tags); * .... @@ -587,8 +640,7 @@ notmuch_thread_get_tags (notmuch_thread_t *thread); void notmuch_thread_destroy (notmuch_thread_t *thread); -/* Does the given notmuch_messages_t object contain any more - * messages. +/* Is the given 'messages' iterator pointing at a valid message. * * When this function returns TRUE, notmuch_messages_get will return a * valid object. Whereas when this function returns FALSE, @@ -598,7 +650,7 @@ notmuch_thread_destroy (notmuch_thread_t *thread); * code showing how to iterate over a notmuch_messages_t object. */ notmuch_bool_t -notmuch_messages_has_more (notmuch_messages_t *messages); +notmuch_messages_valid (notmuch_messages_t *messages); /* Get the current message from 'messages' as a notmuch_message_t. * @@ -614,13 +666,18 @@ notmuch_messages_has_more (notmuch_messages_t *messages); notmuch_message_t * notmuch_messages_get (notmuch_messages_t *messages); -/* Advance the 'messages' iterator to the next result. +/* Move the 'messages' iterator to the next message. + * + * If 'messages' is already pointing at the last message then the + * iterator will be moved to a point just beyond that last message, + * (where notmuch_messages_valid will return FALSE and + * notmuch_messages_get will return NULL). * * See the documentation of notmuch_query_search_messages for example * code showing how to iterate over a notmuch_messages_t object. */ void -notmuch_messages_advance (notmuch_messages_t *messages); +notmuch_messages_move_to_next (notmuch_messages_t *messages); /* Destroy a notmuch_messages_t object. * @@ -688,7 +745,7 @@ notmuch_message_get_thread_id (notmuch_message_t *message); * will return NULL. * * If there are no replies to 'message', this function will return - * NULL. (Note that notmuch_messages_has_more will accept that NULL + * NULL. (Note that notmuch_messages_valid will accept that NULL * value as legitimate, and simply return FALSE for it.) */ notmuch_messages_t * @@ -765,8 +822,8 @@ notmuch_message_get_header (notmuch_message_t *message, const char *header); * message = notmuch_database_find_message (database, message_id); * * for (tags = notmuch_message_get_tags (message); - * notmuch_tags_has_more (tags); - * notmuch_result_advance (tags)) + * notmuch_tags_valid (tags); + * notmuch_result_move_to_next (tags)) * { * tag = notmuch_tags_get (tags); * .... @@ -796,7 +853,7 @@ notmuch_message_get_tags (notmuch_message_t *message); * NOTMUCH_STATUS_TAG_TOO_LONG: The length of 'tag' is too long * (exceeds NOTMUCH_TAG_MAX) * - * NOTMUCH_STATUS_READONLY_DATABASE: Database was opened in read-only + * NOTMUCH_STATUS_READ_ONLY_DATABASE: Database was opened in read-only * mode so message cannot be modified. */ notmuch_status_t @@ -813,7 +870,7 @@ notmuch_message_add_tag (notmuch_message_t *message, const char *tag); * NOTMUCH_STATUS_TAG_TOO_LONG: The length of 'tag' is too long * (exceeds NOTMUCH_TAG_MAX) * - * NOTMUCH_STATUS_READONLY_DATABASE: Database was opened in read-only + * NOTMUCH_STATUS_READ_ONLY_DATABASE: Database was opened in read-only * mode so message cannot be modified. */ notmuch_status_t @@ -824,7 +881,7 @@ notmuch_message_remove_tag (notmuch_message_t *message, const char *tag); * See notmuch_message_freeze for an example showing how to safely * replace tag values. * - * NOTMUCH_STATUS_READONLY_DATABASE: Database was opened in read-only + * NOTMUCH_STATUS_READ_ONLY_DATABASE: Database was opened in read-only * mode so message cannot be modified. */ notmuch_status_t @@ -837,7 +894,7 @@ notmuch_message_remove_all_tags (notmuch_message_t *message); * notmuch_message_remove_all_tags), will not be committed to the * database until the message is thawed with notmuch_message_thaw. * - * Multiple calls to freeze/thaw are valid and these calls with + * Multiple calls to freeze/thaw are valid and these calls will * "stack". That is there must be as many calls to thaw as to freeze * before a message is actually thawed. * @@ -855,7 +912,7 @@ notmuch_message_remove_all_tags (notmuch_message_t *message); * notmuch_message_thaw (message); * * With freeze/thaw used like this, the message in the database is - * guaranteed to have either the full set of original tag value, or + * guaranteed to have either the full set of original tag values, or * the full set of new tag values, but nothing in between. * * Imagine the example above without freeze/thaw and the operation @@ -867,7 +924,7 @@ notmuch_message_remove_all_tags (notmuch_message_t *message); * * NOTMUCH_STATUS_SUCCESS: Message successfully frozen. * - * NOTMUCH_STATUS_READONLY_DATABASE: Database was opened in read-only + * NOTMUCH_STATUS_READ_ONLY_DATABASE: Database was opened in read-only * mode so message cannot be modified. */ notmuch_status_t @@ -888,7 +945,7 @@ notmuch_message_freeze (notmuch_message_t *message); * NOTMUCH_STATUS_SUCCESS: Message successfully thawed, (or at least * its frozen count has successfully been reduced by 1). * - * NOTMUCH_STATUS_UNBALANCE_FREEZE_THAW: An attempt was made to thaw + * NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW: An attempt was made to thaw * an unfrozen message. That is, there have been an unbalanced * number of calls to notmuch_message_freeze and * notmuch_message_thaw. @@ -907,7 +964,7 @@ notmuch_message_thaw (notmuch_message_t *message); void notmuch_message_destroy (notmuch_message_t *message); -/* Does the given notmuch_tags_t object contain any more tags. +/* Is the given 'tags' iterator pointing at a valid tag. * * When this function returns TRUE, notmuch_tags_get will return a * valid string. Whereas when this function returns FALSE, @@ -917,7 +974,7 @@ notmuch_message_destroy (notmuch_message_t *message); * showing how to iterate over a notmuch_tags_t object. */ notmuch_bool_t -notmuch_tags_has_more (notmuch_tags_t *tags); +notmuch_tags_valid (notmuch_tags_t *tags); /* Get the current tag from 'tags' as a string. * @@ -930,13 +987,18 @@ notmuch_tags_has_more (notmuch_tags_t *tags); const char * notmuch_tags_get (notmuch_tags_t *tags); -/* Advance the 'tags' iterator to the next tag. +/* Move the 'tags' iterator to the next tag. + * + * If 'tags' is already pointing at the last tag then the iterator + * will be moved to a point just beyond that last tag, (where + * notmuch_tags_valid will return FALSE and notmuch_tags_get will + * return NULL). * * See the documentation of notmuch_message_get_tags for example code * showing how to iterate over a notmuch_tags_t object. */ void -notmuch_tags_advance (notmuch_tags_t *tags); +notmuch_tags_move_to_next (notmuch_tags_t *tags); /* Destroy a notmuch_tags_t object. * @@ -980,7 +1042,7 @@ notmuch_tags_destroy (notmuch_tags_t *tags); * NOTMUCH_STATUS_XAPIAN_EXCEPTION: A Xapian exception * occurred, mtime not stored. * - * NOTMUCH_STATUS_READONLY_DATABASE: Database was opened in read-only + * NOTMUCH_STATUS_READ_ONLY_DATABASE: Database was opened in read-only * mode so directory mtime cannot be modified. */ notmuch_status_t @@ -990,7 +1052,7 @@ notmuch_directory_set_mtime (notmuch_directory_t *directory, /* Get the mtime of a directory, (as previously stored with * notmuch_directory_set_mtime). * - * Returns 0 if not mtime has previously been stored for this + * Returns 0 if no mtime has previously been stored for this * directory.*/ time_t notmuch_directory_get_mtime (notmuch_directory_t *directory); @@ -1015,8 +1077,7 @@ notmuch_directory_get_child_directories (notmuch_directory_t *directory); void notmuch_directory_destroy (notmuch_directory_t *directory); -/* Does the given notmuch_filenames_t object contain any more - * filenames. +/* Is the given 'filenames' iterator pointing at a valid filename. * * When this function returns TRUE, notmuch_filenames_get will return * a valid string. Whereas when this function returns FALSE, @@ -1026,7 +1087,7 @@ notmuch_directory_destroy (notmuch_directory_t *directory); * function will always return FALSE. */ notmuch_bool_t -notmuch_filenames_has_more (notmuch_filenames_t *filenames); +notmuch_filenames_valid (notmuch_filenames_t *filenames); /* Get the current filename from 'filenames' as a string. * @@ -1039,13 +1100,18 @@ notmuch_filenames_has_more (notmuch_filenames_t *filenames); const char * notmuch_filenames_get (notmuch_filenames_t *filenames); -/* Advance the 'filenames' iterator to the next filename. +/* Move the 'filenames' iterator to the next filename. + * + * If 'filenames' is already pointing at the last filename then the + * iterator will be moved to a point just beyond that last filename, + * (where notmuch_filenames_valid will return FALSE and + * notmuch_filenames_get will return NULL). * * It is acceptable to pass NULL for 'filenames', in which case this * function will do nothing. */ void -notmuch_filenames_advance (notmuch_filenames_t *filenames); +notmuch_filenames_move_to_next (notmuch_filenames_t *filenames); /* Destroy a notmuch_filenames_t object. *