*
* NOTMUCH_STATUS_SUCCESS: No error occurred.
*
+ * XXX: We don't really want to expose this lame XAPIAN_EXCEPTION
+ * value. Instead we should map to things like DATABASE_LOCKED or
+ * whatever.
+ *
* NOTMUCH_STATUS_XAPIAN_EXCEPTION: A Xapian exception occurred
*
* NOTMUCH_STATUS_FILE_NOT_EMAIL: A file was presented that doesn't
* appear to be an email message.
+ *
+ * NOTMUCH_STATUS_NULL_POINTER: The user erroneously passed a NULL
+ * pointer to a notmuch function.
+ *
+ * NOTMUCH_STATUS_TAG_TOO_LONG: A tag value is too long.
+ *
+ * NOTMUCH_STATUS_LAST_STATUS: Not an actual status value. Just a way
+ * to find out how many valid status values there are.
*/
typedef enum _notmuch_status {
NOTMUCH_STATUS_SUCCESS = 0,
NOTMUCH_STATUS_XAPIAN_EXCEPTION,
- NOTMUCH_STATUS_FILE_NOT_EMAIL
+ NOTMUCH_STATUS_FILE_NOT_EMAIL,
+ NOTMUCH_STATUS_NULL_POINTER,
+ NOTMUCH_STATUS_TAG_TOO_LONG,
+
+ NOTMUCH_STATUS_LAST_STATUS
} notmuch_status_t;
+/* Get a string representation of a notmuch_status_t value.
+ *
+ * The result is readonly.
+ */
+const char *
+notmuch_status_to_string (notmuch_status_t status);
+
/* Various opaque data types. For each notmuch_<foo>_t see the various
* notmuch_<foo> functions below. */
typedef struct _notmuch_database notmuch_database_t;
typedef struct _notmuch_results notmuch_results_t;
typedef struct _notmuch_message notmuch_message_t;
typedef struct _notmuch_tags notmuch_tags_t;
+typedef struct _notmuch_thread_ids notmuch_thread_ids_t;
/* Create a new, empty notmuch database located at 'path'.
*
notmuch_database_add_message (notmuch_database_t *database,
const char *filename);
+/* Find a message with the given messsage_id.
+ *
+ * If the database contains a message with the given message_id, then
+ * 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, this function
+ * returns NULL.
+ */
+notmuch_message_t *
+notmuch_database_find_message (notmuch_database_t *database,
+ const char *message_id);
+
/* Create a new query for 'database'.
*
* Here, 'database' should be an open database, (see
*
* http://xapian.org/docs/queryparser.html
*
- * As a special case, passing a value of NOTMUCH_QUERY_ALL for the
- * query string will result in a query that returns all messages in
- * the database.
+ * As a special case, passing a length-zero string, (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.
notmuch_query_create (notmuch_database_t *database,
const char *query_string);
-/* Special value to cause notmuch_query_create to return all
- * messages. */
-extern const char *NOTMUCH_QUERY_ALL;
-
/* Sort values for notmuch_query_set_sort */
typedef enum {
NOTMUCH_SORT_DATE_OLDEST_FIRST,
* {
* message = notmuch_results_get (results);
* ....
+ * notmuch_message_destroy (message);
* }
*
* notmuch_query_destroy (query);
*
- * Note that there's no explicit destructor for the notmuch_results_t
- * object.
+ * Note: If you are finished with a message before its containing
+ * query, you can call notmuch_message_destroy to clean up some memory
+ * sooner (as in the above example). Otherwise, if your message
+ * objects are long-lived, then you don't need to call
+ * notmuch_message_destroy and all the memory will still be reclaimed
+ * 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_results_t *
notmuch_query_search (notmuch_query_t *query);
void
notmuch_results_advance (notmuch_results_t *results);
+/* Destroy a notmuch_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.
+ */
+void
+notmuch_results_destroy (notmuch_results_t *results);
+
/* Get the message ID of 'message'.
*
* The returned string belongs to 'message' and as such, should not be
* notmuch_tags_t *tags;
* const char *tag;
*
- * message = notmuch_results_get (results);
+ * message = notmuch_database_find_message (database, message_id);
*
* for (tags = notmuch_message_get_tags (message);
* notmuch_tags_has_more (tags);
* notmuch_result_advance (tags))
* {
- * tag = notmuch_tags_get_string (tags);
+ * tag = notmuch_tags_get (tags);
* ....
* }
*
- * Note that there's no explicit destructor for the notmuch_tags_t
- * object.
+ * notmuch_message_destroy (message);
+ *
+ * Note that there's no explicit destructor needed for the
+ * notmuch_tags_t object. (For consistency, we do provide a
+ * notmuch_tags_destroy function, but there's no good reason to call
+ * it if the message is about to be destroyed).
*/
notmuch_tags_t *
notmuch_message_get_tags (notmuch_message_t *message);
-/* Does the given notmuch_tags_t object contain any more results.
+/* Get the thread IDs for 'message', returning a notmuch_thread_ids_t
+ * object which can be used to iterate over all thread IDs.
+ *
+ * The thread_ids object is owned by the message and as such, will
+ * only be valid for as long as the message is valid, (which is until
+ * the query from which it derived is destroyed).
+ *
+ * Typical usage might be:
+ *
+ * notmuch_message_t *message;
+ * notmuch_thread_ids_t *thread_ids;
+ * const char *thread_id;
+ *
+ * message = notmuch_database_find_message (database, message_id);
+ *
+ * for (thread_ids = notmuch_message_get_thread_ids (message);
+ * notmuch_thread_ids_has_more (thread_ids);
+ * notmuch_thread_ids_advance (thread_ids))
+ * {
+ * thread_id = notmuch_thread_ids_get (thread_ids);
+ * ....
+ * }
+ *
+ * notmuch_message_destroy (message);
+ *
+ * Note that there's no explicit destructor needed for the
+ * notmuch_thread_ids_t object. (For consistency, we do provide a
+ * notmuch_thread_ids_destroy function, but there's no good reason to
+ * call it if the message is about to be destroyed).
+ */
+notmuch_thread_ids_t *
+notmuch_message_get_thread_ids (notmuch_message_t *message);
+
+/* The longest possible tag value. */
+#define NOTMUCH_TAG_MAX 200
+
+/* Add a tag to the given message.
+ *
+ * Return value:
+ *
+ * NOTMUCH_STATUS_SUCCESS: Tag successfully added to message
+ *
+ * NOTMUCH_STATUS_NULL_POINTER: The 'tag' argument is NULL
+ *
+ * NOTMUCH_STATUS_TAG_TOO_LONG: The length of 'tag' is longer than
+ * too long (exceeds NOTMUCH_TAG_MAX)
+ */
+notmuch_status_t
+notmuch_message_add_tag (notmuch_message_t *message, const char *tag);
+
+/* Remove a tag from the given message.
+ *
+ * Return value:
+ *
+ * NOTMUCH_STATUS_SUCCESS: Tag successfully added to message
+ *
+ * NOTMUCH_STATUS_NULL_POINTER: The 'tag' argument is NULL
+ *
+ * NOTMUCH_STATUS_TAG_TOO_LONG: The length of 'tag' is longer than
+ * too long (exceeds NOTMUCH_TAG_MAX)
+ */
+notmuch_status_t
+notmuch_message_remove_tag (notmuch_message_t *message, const char *tag);
+
+/* Destroy a notmuch_message_t object.
+ *
+ * It can be useful to call this function in the case of a single
+ * query object with many messages in the result, (such as iterating
+ * over the entire database). Otherwise, it's fine to never call this
+ * function and there will still be no memory leaks. (The memory from
+ * the messages get reclaimed when the containing query is destroyed.)
+ */
+void
+notmuch_message_destroy (notmuch_message_t *message);
+
+/* Does the given notmuch_tags_t object contain any more tags.
*
* When this function returns TRUE, notmuch_tags_get will return a
* valid string. Whereas when this function returns FALSE,
notmuch_bool_t
notmuch_tags_has_more (notmuch_tags_t *tags);
-/* Get the current result from 'tags' as a string.
+/* Get the current tag from 'tags' as a string.
*
* Note: The returned string belongs to 'tags' and has a lifetime
* identical to it (and the query to which it utlimately belongs).
* showing how to iterate over a notmuch_tags_t object.
*/
void
-notmuch_tags_advance (notmuch_tags_t *results);
+notmuch_tags_advance (notmuch_tags_t *tags);
+
+/* Destroy a notmuch_tags_t object.
+ *
+ * It's not strictly necessary to call this function. All memory from
+ * the notmuch_tags_t object will be reclaimed when the containg
+ * message or query objects are destroyed.
+ */
+void
+notmuch_tags_destroy (notmuch_tags_t *tags);
+
+/* Does the given notmuch_thread_ids_t object contain any more thread IDs.
+ *
+ * When this function returns TRUE, notmuch_thread_ids_get will return a
+ * valid string. Whereas when this function returns FALSE,
+ * notmuch_thread_ids_get will return NULL.
+ *
+ * See the documentation of notmuch_message_get_thread_ids for example code
+ * showing how to iterate over a notmuch_thread_ids_t object.
+ */
+notmuch_bool_t
+notmuch_thread_ids_has_more (notmuch_thread_ids_t *thread_ids);
+
+/* Get the current thread ID from 'thread_ids' as a string.
+ *
+ * Note: The returned string belongs to 'thread_ids' and has a lifetime
+ * identical to it (and the query to which it utlimately belongs).
+ *
+ * See the documentation of notmuch_message_get_thread_ids for example code
+ * showing how to iterate over a notmuch_thread_ids_t object.
+ */
+const char *
+notmuch_thread_ids_get (notmuch_thread_ids_t *thread_ids);
+
+/* Advance the 'thread_ids' iterator to the next tag.
+ *
+ * See the documentation of notmuch_message_get_thread_ids for example code
+ * showing how to iterate over a notmuch_thread_ids_t object.
+ */
+void
+notmuch_thread_ids_advance (notmuch_thread_ids_t *thread_ids);
+
+/* Destroy a notmuch_thread_ids_t object.
+ *
+ * It's not strictly necessary to call this function. All memory from
+ * the notmuch_thread_ids_t object will be reclaimed when the containg
+ * message or query objects are destroyed.
+ */
+void
+notmuch_thread_ids_destroy (notmuch_thread_ids_t *thread_ids);
NOTMUCH_END_DECLS