* (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'.
* 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'.
+ *
+ * Can return NULL if a Xapian exception occurs.
*/
notmuch_directory_t *
notmuch_database_get_directory (notmuch_database_t *database,
* notmuch database will reference the filename, and will not copy the
* entire contents of the file.
*
- * If 'message' is not NULL, then, on successful return '*message'
+ * If 'message' is not NULL, then, on successful return
+ * (NOTMUCH_STATUS_SUCCESS or NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) '*message'
* will be initialized to a message object that can be used for things
* such as adding tags to the just-added message. The user should call
* notmuch_message_destroy when done with the message. On any failure
*
* 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,
* 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.
* 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,
*
* 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.
typedef enum {
NOTMUCH_SORT_OLDEST_FIRST,
NOTMUCH_SORT_NEWEST_FIRST,
- NOTMUCH_SORT_MESSAGE_ID
+ NOTMUCH_SORT_MESSAGE_ID,
+ NOTMUCH_SORT_UNSORTED
} notmuch_sort_t;
+/* Return the query_string of this query. See notmuch_query_create. */
+const char *
+notmuch_query_get_query_string (notmuch_query_t *query);
+
/* Specify the sorting desired for this query. */
void
notmuch_query_set_sort (notmuch_query_t *query, notmuch_sort_t sort);
+/* Return the sort specified for this query. See notmuch_query_set_sort. */
+notmuch_sort_t
+notmuch_query_get_sort (notmuch_query_t *query);
+
/* 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
* 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);
* ....
* 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);
* 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);
* ....
* 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);
*
* 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.
*
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.
*
*
* 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);
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);
* 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);
* ....
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,
* 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.
*
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.
*
* 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 *
/* Message flags */
typedef enum _notmuch_message_flag {
NOTMUCH_MESSAGE_FLAG_MATCH,
+ NOTMUCH_MESSAGE_FLAG_TAGS_INVALID,
} notmuch_message_flag_t;
/* Get a value of a flag for the email corresponding to 'message'. */
* 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);
* ....
notmuch_status_t
notmuch_message_remove_all_tags (notmuch_message_t *message);
+/* Add or remove tags based on the maildir flags in the file name.
+ */
+notmuch_status_t
+notmuch_message_maildir_to_tags (notmuch_message_t *message,
+ const char *filename);
+
/* Freeze the current state of 'message' within the database.
*
* This means that changes to the message state, (via
* 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.
*
* 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
* 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.
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,
* 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.
*
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.
*
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,
* 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.
*
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.
*
projects / notmuch / blobdiff