X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=lib%2Fnotmuch.h;h=bfcd47026c638df720d9d96a5811b92c4c0bc551;hp=89ed7ad88b7eb91ead3d6cefe518f29b410cdfd2;hb=95deec1b2767695bce5f4e3dc3336859825682f7;hpb=f379aa52845f5594aa6cc2e7cf131d5f57202bbf diff --git a/lib/notmuch.h b/lib/notmuch.h index 89ed7ad8..bfcd4702 100644 --- a/lib/notmuch.h +++ b/lib/notmuch.h @@ -114,6 +114,8 @@ typedef struct _notmuch_thread notmuch_thread_t; typedef struct _notmuch_messages notmuch_messages_t; typedef struct _notmuch_message notmuch_message_t; typedef struct _notmuch_tags notmuch_tags_t; +typedef struct _notmuch_directory notmuch_directory_t; +typedef struct _notmuch_files notmuch_files_t; /* Create a new, empty notmuch database located at 'path'. * @@ -137,14 +139,14 @@ typedef struct _notmuch_tags notmuch_tags_t; notmuch_database_t * notmuch_database_create (const char *path); -/* XXX: I think I'd like this to take an extra argument of - * notmuch_status_t* for returning a status value on failure. */ - typedef enum { - NOTMUCH_DATABASE_MODE_READONLY = 0, - NOTMUCH_DATABASE_MODE_WRITABLE + NOTMUCH_DATABASE_MODE_READ_ONLY = 0, + NOTMUCH_DATABASE_MODE_READ_WRITE } notmuch_database_mode_t; +/* XXX: I think I'd like this to take an extra argument of + * notmuch_status_t* for returning a status value on failure. */ + /* Open an existing notmuch database located at 'path'. * * The database should have been created at some time in the past, @@ -178,56 +180,47 @@ notmuch_database_close (notmuch_database_t *database); const char * notmuch_database_get_path (notmuch_database_t *database); -/* Store a timestamp within the database. - * - * The Notmuch database will not interpret this key nor the timestamp - * values at all. It will merely store them together and return the - * timestamp when notmuch_database_get_timestamp is called with the - * same value for 'key'. - * - * The intention is for the caller to use the timestamp to allow - * efficient identification of new messages to be added to the - * database. The recommended usage is as follows: +/* Read the stored contents of a directory from the database. * - * o Read the mtime of a directory from the filesystem - * - * o Call add_message for all mail files in the directory - * - * o Call notmuch_database_set_timestamp with the path of the - * directory as 'key' and the originally read mtime as 'value'. - * - * Then, when wanting to check for updates to the directory in the - * future, the client can call notmuch_database_get_timestamp and know - * that it only needs to add files if the mtime of the directory and - * files are newer than the stored timestamp. - * - * Note: The notmuch_database_get_timestamp function does not allow - * the caller to distinguish a timestamp of 0 from a non-existent - * timestamp. So don't store a timestamp of 0 unless you are - * comfortable with that. - * - * Return value: - * - * NOTMUCH_STATUS_SUCCESS: Timestamp successfully stored in database. + * Here, 'dirname' should be a path relative to the path of + * 'database' (see notmuch_database_get_path), or else should be an + * absolute filename with initial components that match the path of + * 'database'. * - * NOTMUCH_STATUS_XAPIAN_EXCEPTION: A Xapian exception - * occurred. Timestamp not stored. + * The stored mtime of the directory along with a list of messages + * and directories in the database contained in 'dirname' are + * returned in 'directory'. The entries are sorted by filename. */ notmuch_status_t -notmuch_database_set_timestamp (notmuch_database_t *database, - const char *key, time_t timestamp); +notmuch_database_read_directory (notmuch_database_t *database, + const char *filename, + notmuch_directory_t **directory); -/* Retrieve a timestamp from the database. - * - * Returns the timestamp value previously stored by calling - * notmuch_database_set_timestamp with the same value for 'key'. - * - * Returns 0 if no timestamp is stored for 'key' or if any error - * occurred querying the database. +/* Return the recorded 'mtime' for the given directory */ time_t -notmuch_database_get_timestamp (notmuch_database_t *database, - const char *key); +notmuch_directory_get_mtime (notmuch_directory_t *directory); + +/* Return a notmuch_files_t iterator for all regular files in 'directory'. + */ +notmuch_files_t * +notmuch_directory_get_files (notmuch_directory_t *directory); + +/* Return a notmuch_files_t iterator for all sub-directories of + * 'directory'. + */ +notmuch_files_t * +notmuch_directory_get_subdirs (notmuch_directory_t *directory); + +/* Does the given notmuch_files_t object contain any more results. + */ +notmuch_bool_t +notmuch_files_has_more (notmuch_files_t *files); + +/* Get the current filename from 'files' as a string. + */ +const char * +notmuch_files_get_filename (notmuch_files_t *files); /* Add a new message to the given notmuch database. * @@ -267,6 +260,19 @@ notmuch_database_add_message (notmuch_database_t *database, const char *filename, notmuch_message_t **message); +/* Remove a message from the given notmuch database. + * + * Note that the only this particular filename association is removed + * from the database. If the same message (as determined by the + * message ID) is still available via other filenames, then the + * message will persist in the database for those filenames. When the + * last filename is removed for a particular message, the database + * content for that message will be entirely removed. + */ +notmuch_status_t +notmuch_database_remove_message (notmuch_database_t *database, + const char *filename); + /* Find a message with the given message_id. * * If the database contains a message with the given message_id, then @@ -280,6 +286,16 @@ notmuch_message_t * notmuch_database_find_message (notmuch_database_t *database, const char *message_id); +/* Return a list of all tags found in the database. + * + * This function creates a list of all tags found in the database. The + * resulting list contains all tags from all messages found in the database. + * + * On error this function returns NULL. + */ +notmuch_tags_t * +notmuch_database_get_all_tags (notmuch_database_t *db); + /* Create a new query for 'database'. * * Here, 'database' should be an open database, (see @@ -322,14 +338,6 @@ notmuch_query_set_sort (notmuch_query_t *query, notmuch_sort_t sort); * object is owned by the query and as such, will only be valid until * notmuch_query_destroy. * - * The 'first' and 'max_threads' arguments can be used to obtain - * partial results from the search. For example, to get results 10 at - * a time, pass 'max_threads' as 10 and for 'first' pass the values 0, - * 10, 20, etc. As a special case, a value of -1 for 'max_threads' - * indicates that no limiting is to be performed. So a search with - * 'first' == 0 and 'max_threads' == -1 will return the complete - * results of the search. - * * Typical usage might be: * * notmuch_query_t *query; @@ -362,22 +370,13 @@ notmuch_query_set_sort (notmuch_query_t *query, notmuch_sort_t sort); * to call it if the query is about to be destroyed). */ notmuch_threads_t * -notmuch_query_search_threads (notmuch_query_t *query, - int first, int max_threads); +notmuch_query_search_threads (notmuch_query_t *query); /* 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. * - * The 'first' and 'max_messages' arguments can be used to obtain - * partial results from the search. For example, to get results 10 at - * a time, pass 'max_messages' as 10 and for 'first' pass the values - * 0, 10, 20, etc. As a special case, a value of -1 for 'max_messages' - * indicates that no limiting is to be performed. So a search with - * 'first' == 0 and 'max_messages' == -1 will return the complete - * results of the search. - * * Typical usage might be: * * notmuch_query_t *query; @@ -410,8 +409,7 @@ notmuch_query_search_threads (notmuch_query_t *query, * reason to call it if the query is about to be destroyed). */ notmuch_messages_t * -notmuch_query_search_messages (notmuch_query_t *query, - int first, int max_messages); +notmuch_query_search_messages (notmuch_query_t *query); /* Destroy a notmuch_query_t along with any associated resources. * @@ -468,6 +466,14 @@ notmuch_threads_advance (notmuch_threads_t *threads); void notmuch_threads_destroy (notmuch_threads_t *threads); +/* Return an estimate of the number of messages matching a search + * + * This function performs a search and returns Xapian's best + * guess as to number of matching messages. + */ +unsigned +notmuch_query_count_messages (notmuch_query_t *query); + /* Get the thread ID of 'thread'. * * The returned string belongs to 'thread' and as such, should not be @@ -635,6 +641,21 @@ notmuch_messages_advance (notmuch_messages_t *messages); void notmuch_messages_destroy (notmuch_messages_t *messages); +/* Return a list of tags from all messages. + * + * The resulting list is guaranteed not to contain duplicated tags. + * + * WARNING: You can no longer iterate over messages after calling this + * function, because the iterator will point at the end of the list. + * We do not have a function to reset the iterator yet and the only + * way how you can iterate over the list again is to recreate the + * message list. + * + * The function returns NULL on error. + */ +notmuch_tags_t * +notmuch_messages_collect_tags (notmuch_messages_t *messages); + /* Get the message ID of 'message'. * * The returned string belongs to 'message' and as such, should not be @@ -683,17 +704,48 @@ notmuch_message_get_thread_id (notmuch_message_t *message); notmuch_messages_t * notmuch_message_get_replies (notmuch_message_t *message); -/* Get the filename for the email corresponding to 'message'. +/* Get a filename for the email corresponding to 'message'. * * The returned filename is an absolute filename, (the initial * component will match notmuch_database_get_path() ). * * The returned string belongs to the message so should not be * modified or freed by the caller (nor should it be referenced after - * the message is destroyed). */ + * the message is destroyed). + * + * Note: If this message corresponds to multiple files in the mail + * store, (that is, multiple files contain identical message IDs), + * this function will arbitrarily return a single one of those + * filenames. + */ const char * notmuch_message_get_filename (notmuch_message_t *message); +/* Remove a filename for the email corresponding to 'message'. + * + * This removes the association between a filename and a message, + * when the last filename is gone, the entire message is removed + * from the database. + */ +notmuch_status_t +notmuch_message_remove_filename (notmuch_message_t *message, + const char *filename); + +/* Message flags */ +typedef enum _notmuch_message_flag { + NOTMUCH_MESSAGE_FLAG_MATCH, +} notmuch_message_flag_t; + +/* Get a value of a flag for the email corresponding to 'message'. */ +notmuch_bool_t +notmuch_message_get_flag (notmuch_message_t *message, + notmuch_message_flag_t flag); + +/* Set a value of a flag for the email corresponding to 'message'. */ +void +notmuch_message_set_flag (notmuch_message_t *message, + notmuch_message_flag_t flag, notmuch_bool_t value); + /* Get the date of 'message' as a time_t value. * * For the original textual representation of the Date header from the