notmuch

package module
v0.0.0-...-bcfc52d Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: May 1, 2018 License: LGPL-2.1 Imports: 2 Imported by: 1

README

Notmuch Go Bindings

This is a fork of the Go bindings that are part of the official notmuch repository (github.com/notmuch/notmuch/contrib/go/src/notmuch).

I used to have a full fork of the repository on my github account, but since everything kind of diverged and it is cleaner in Go to have it like this, I decided to maintain just this file from now on.

Documentation

Overview

Package notmuch provides Go bindings for the notmuch library.

Index

Constants

View Source
const TAG_MAX = 200

The longest possible tag value.

Variables

This section is empty.

Functions

func NewDatabase

func NewDatabase(path string) (*Database, Status)

Create a new, empty notmuch database located at 'path'

func OpenDatabase

func OpenDatabase(path string, mode DatabaseMode) (*Database, Status)

Open an existing notmuch database located at 'path'.

The database should have been created at some time in the past, (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_READ_WRITE mode.

An existing notmuch database can be identified by the presence of a directory named ".notmuch" below 'path'.

The caller should call notmuch_database_destroy when finished with this database.

In case of any failure, this function returns NULL, (after printing an error message on stderr).

Types

type Database

type Database struct {
	// contains filtered or unexported fields
}

func (*Database) AddMessage

func (self *Database) AddMessage(fname string) (*Message, Status)

Add a new message to the given notmuch database.

Here,'filename' 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'.

The file should be a single mail message (not a multi-message mbox) that is expected to remain at its current location, (since the 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' 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 '*message' will be set to NULL.

Return value:

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 (if not already present).

NOTMUCH_STATUS_FILE_ERROR: an error occurred trying to open the file, (such as permission denied, or file not found, etc.). Nothing added to the database.

NOTMUCH_STATUS_FILE_NOT_EMAIL: the contents of filename don't look like an email message. Nothing added to the database.

NOTMUCH_STATUS_READ_ONLY_DATABASE: Database was opened in read-only mode so no message can be added.

func (*Database) Close

func (self *Database) Close() Status

Close the given notmuch database, freeing all associated resources. See notmuch_database_open.

func (*Database) CreateQuery

func (self *Database) CreateQuery(query string) *Query

Create a new query for 'database'.

Here, 'database' should be an open database, (see notmuch_database_open and notmuch_database_create).

For the query string, we'll document the syntax here more completely in the future, but it's likely to be a specialized version of the general Xapian query syntax:

http://xapian.org/docs/queryparser.html

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. 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.

Will return NULL if insufficient memory is available.

func (*Database) FindMessage

func (self *Database) FindMessage(message_id string) (*Message, Status)

Find a message with the given message_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.

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

func (*Database) GetAllTags

func (self *Database) GetAllTags() *Tags

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.

func (*Database) GetDirectory

func (self *Database) GetDirectory(path string) (*Directory, Status)

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'.

Can return NULL if a Xapian exception occurs.

func (*Database) GetPath

func (self *Database) GetPath() string

Return the database path of the given database.

func (*Database) GetVersion

func (self *Database) GetVersion() uint

Return the database format version of the given database.

func (*Database) NeedsUpgrade

func (self *Database) NeedsUpgrade() bool

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.

func (*Database) RemoveMessage

func (self *Database) RemoveMessage(fname string) Status

Remove a message from the given notmuch database.

Note that 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.

Return value:

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_READ_ONLY_DATABASE: Database was opened in read-only mode so no message can be removed.

type DatabaseMode

type DatabaseMode C.notmuch_database_mode_t
const (
	DATABASE_MODE_READ_ONLY DatabaseMode = iota
	DATABASE_MODE_READ_WRITE
)

type Directory

type Directory struct {
	// contains filtered or unexported fields
}

func (*Directory) Destroy

func (self *Directory) Destroy()

Destroy a notmuch_directory_t object.

type Filenames

type Filenames struct {
	// contains filtered or unexported fields
}

func (*Filenames) Destroy

func (self *Filenames) Destroy()

Destroy a notmuch_filenames_t object.

It's not strictly necessary to call this function. All memory from the notmuch_filenames_t object will be reclaimed when the containing directory object is destroyed.

It is acceptable to pass NULL for 'filenames', in which case this function will do nothing.

type Flag

const (
	MESSAGE_FLAG_MATCH Flag = iota
)

type Message

type Message struct {
	// contains filtered or unexported fields
}

func (*Message) AddTag

func (self *Message) AddTag(tag string) Status

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 too long (exceeds NOTMUCH_TAG_MAX)

NOTMUCH_STATUS_READ_ONLY_DATABASE: Database was opened in read-only mode so message cannot be modified.

func (*Message) Destroy

func (self *Message) Destroy()

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.)

func (*Message) Freeze

func (self *Message) Freeze() Status

Freeze the current state of 'message' within the database.

This means that changes to the message state, (via notmuch_message_add_tag, notmuch_message_remove_tag, and 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 will "stack". That is there must be as many calls to thaw as to freeze before a message is actually thawed.

The ability to do freeze/thaw allows for safe transactions to change tag values. For example, explicitly setting a message to have a given set of tags might look like this:

notmuch_message_freeze (message);

notmuch_message_remove_all_tags (message);

for (i = 0; i < NUM_TAGS; i++)
    notmuch_message_add_tag (message, tags[i]);

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 values, or the full set of new tag values, but nothing in between.

Imagine the example above without freeze/thaw and the operation somehow getting interrupted. This could result in the message being left with no tags if the interruption happened after notmuch_message_remove_all_tags but before notmuch_message_add_tag.

Return value:

NOTMUCH_STATUS_SUCCESS: Message successfully frozen.

NOTMUCH_STATUS_READ_ONLY_DATABASE: Database was opened in read-only mode so message cannot be modified.

func (*Message) GetDate

func (self *Message) GetDate() (int64, Status)

Get the timestamp (seconds since the epoch) of 'message'.

Return status:

NOTMUCH_STATUS_SUCCESS: Timestamp successfully retrieved

NOTMUCH_STATUS_NULL_POINTER: The 'message' argument is NULL

func (*Message) GetFileName

func (self *Message) GetFileName() string

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).

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.

func (*Message) GetFlag

func (self *Message) GetFlag(flag Flag) bool

Get a value of a flag for the email corresponding to 'message'.

func (*Message) GetHeader

func (self *Message) GetHeader(header string) string

Get the value of the specified header from 'message'.

The value will be read from the actual message file, not from the notmuch database. The header name is case insensitive.

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).

Returns an empty string ("") if the message does not contain a header line matching 'header'. Returns NULL if any error occurs.

func (*Message) GetMessageId

func (self *Message) GetMessageId() string

Get the message ID of 'message'.

The returned string belongs to 'message' and as such, should not be modified by the caller and will only be valid for as long as the message is valid, (which is until the query from which it derived is destroyed).

This function will not return NULL since Notmuch ensures that every message has a unique message ID, (Notmuch will generate an ID for a message if the original file does not contain one).

func (*Message) GetReplies

func (self *Message) GetReplies() *Messages

Get a notmuch_messages_t iterator for all of the replies to 'message'.

Note: This call only makes sense if 'message' was ultimately obtained from a notmuch_thread_t object, (such as by coming directly from the result of calling notmuch_thread_get_ toplevel_messages or by any number of subsequent calls to notmuch_message_get_replies).

If 'message' was obtained through some non-thread means, (such as by a call to notmuch_query_search_messages), then this function will return NULL.

If there are no replies to 'message', this function will return NULL. (Note that notmuch_messages_valid will accept that NULL value as legitimate, and simply return FALSE for it.)

func (*Message) GetTags

func (self *Message) GetTags() *Tags

Get the tags for 'message', returning a notmuch_tags_t object which can be used to iterate over all tags.

The tags 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_tags_t *tags;
const char *tag;

message = notmuch_database_find_message (database, message_id);

for (tags = notmuch_message_get_tags (message);
     notmuch_tags_valid (tags);
     notmuch_result_move_to_next (tags))
{
    tag = notmuch_tags_get (tags);
    ....
}

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).

func (*Message) GetThreadId

func (self *Message) GetThreadId() string

Get the thread ID of 'message'.

The returned string belongs to 'message' and as such, should not be modified by the caller and will only be valid for as long as the message is valid, (for example, until the user calls notmuch_message_destroy on 'message' or until a query from which it derived is destroyed).

This function will not return NULL since Notmuch ensures that every message belongs to a single thread.

func (*Message) RemoveAllTags

func (self *Message) RemoveAllTags() Status

Remove all tags from the given message.

See notmuch_message_freeze for an example showing how to safely replace tag values.

NOTMUCH_STATUS_READ_ONLY_DATABASE: Database was opened in read-only mode so message cannot be modified.

func (*Message) RemoveTag

func (self *Message) RemoveTag(tag string) Status

Remove a tag from the given message.

Return value:

NOTMUCH_STATUS_SUCCESS: Tag successfully removed from message

NOTMUCH_STATUS_NULL_POINTER: The 'tag' argument is NULL

NOTMUCH_STATUS_TAG_TOO_LONG: The length of 'tag' is too long (exceeds NOTMUCH_TAG_MAX)

NOTMUCH_STATUS_READ_ONLY_DATABASE: Database was opened in read-only mode so message cannot be modified.

func (*Message) SetFlag

func (self *Message) SetFlag(flag Flag, value bool)

Set a value of a flag for the email corresponding to 'message'.

func (*Message) TagsToMaildirFlags

func (self *Message) TagsToMaildirFlags() Status

Rename message filename(s) to encode tags as maildir flags.

Specifically, for each filename corresponding to this message:

If the filename is not in a maildir directory, do nothing. (A maildir directory is determined as a directory named "new" or "cur".) Similarly, if the filename has invalid maildir info, (repeated or outof-ASCII-order flag characters after ":2,"), then do nothing.

If the filename is in a maildir directory, rename the file so that its filename ends with the sequence ":2," followed by zero or more of the following single-character flags (in ASCII order):

'D' iff the message has the "draft" tag
'F' iff the message has the "flagged" tag
'P' iff the message has the "passed" tag
'R' iff the message has the "replied" tag
'S' iff the message does not have the "unread" tag

Any existing flags unmentioned in the list above will be preserved in the renaming.

Also, if this filename is in a directory named "new", rename it to be within the neighboring directory named "cur".

A client can ensure that maildir filename flags remain synchronized with notmuch database tags by calling this function after changing tags, (after calls to notmuch_message_add_tag, notmuch_message_remove_tag, or notmuch_message_freeze/ notmuch_message_thaw). See also notmuch_message_maildir_flags_to_tags for synchronizing maildir flag changes back to tags.

func (*Message) Thaw

func (self *Message) Thaw() Status

Thaw the current 'message', synchronizing any changes that may have occurred while 'message' was frozen into the notmuch database.

See notmuch_message_freeze for an example of how to use this function to safely provide tag changes.

Multiple calls to freeze/thaw are valid and these calls with "stack". That is there must be as many calls to thaw as to freeze before a message is actually thawed.

Return value:

NOTMUCH_STATUS_SUCCESS: Message successfully thawed, (or at least its frozen count has successfully been reduced by 1).

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.

type Messages

type Messages struct {
	// contains filtered or unexported fields
}

func (*Messages) CollectTags

func (self *Messages) CollectTags() *Tags

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.

func (*Messages) Destroy

func (self *Messages) Destroy()

Destroy a notmuch_messages_t object.

It's not strictly necessary to call this function. All memory from the notmuch_messages_t object will be reclaimed when the containing query object is destroyed.

func (*Messages) Get

func (self *Messages) Get() *Message

Get the current message from 'messages' as a notmuch_message_t.

Note: The returned message belongs to 'messages' and has a lifetime identical to it (and the query to which it belongs).

See the documentation of notmuch_query_search_messages for example code showing how to iterate over a notmuch_messages_t object.

If an out-of-memory situation occurs, this function will return NULL.

func (*Messages) MoveToNext

func (self *Messages) MoveToNext()

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.

func (*Messages) Valid

func (self *Messages) Valid() bool

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, 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.

type Query

type Query struct {
	// contains filtered or unexported fields
}

func (*Query) CountMessages

func (self *Query) CountMessages() uint

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.

If a Xapian exception occurs, this function may return 0 (after printing a message).

func (*Query) Destroy

func (self *Query) Destroy()

Destroy a notmuch_query_t along with any associated resources.

This will in turn destroy any notmuch_threads_t and notmuch_messages_t objects generated by this query, (and in turn any notmuch_thread_t and notmuch_message_t objects generated from those results, etc.), if such objects haven't already been destroyed.

func (*Query) GetSort

func (self *Query) GetSort() Sort

Return the sort specified for this query. See notmuch_query_set_sort.

func (*Query) SearchMessages

func (self *Query) SearchMessages() *Messages

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.

Typical usage might be:

notmuch_query_t *query;
notmuch_messages_t *messages;
notmuch_message_t *message;

query = notmuch_query_create (database, query_string);

for (messages = notmuch_query_search_messages (query);
     notmuch_messages_valid (messages);
     notmuch_messages_move_to_next (messages))
{
    message = notmuch_messages_get (messages);
    ....
    notmuch_message_destroy (message);
}

notmuch_query_destroy (query);

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_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.

func (*Query) SearchThreads

func (self *Query) SearchThreads() *Threads

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 notmuch_query_destroy.

Typical usage might be:

notmuch_query_t *query;
notmuch_threads_t *threads;
notmuch_thread_t *thread;

query = notmuch_query_create (database, query_string);

for (threads = notmuch_query_search_threads (query);
     notmuch_threads_valid (threads);
     notmuch_threads_move_to_next (threads))
{
    thread = notmuch_threads_get (threads);
    ....
    notmuch_thread_destroy (thread);
}

notmuch_query_destroy (query);

Note: If you are finished with a thread before its containing query, you can call notmuch_thread_destroy to clean up some memory sooner (as in the above example). Otherwise, if your thread objects are long-lived, then you don't need to call notmuch_thread_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_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.

func (*Query) SetSort

func (self *Query) SetSort(sort Sort)

Specify the sorting desired for this query.

func (*Query) String

func (self *Query) String() string

Return the query_string of this query. See notmuch_query_create.

type Sort

type Sort C.notmuch_sort_t

Sort values for notmuch_query_set_sort

const (
	SORT_OLDEST_FIRST Sort = iota
	SORT_NEWEST_FIRST
	SORT_MESSAGE_ID
	SORT_UNSORTED
)

type Status

type Status C.notmuch_status_t

Status codes used for the return values of most functions

const (
	STATUS_SUCCESS Status = iota
	STATUS_OUT_OF_MEMORY
	STATUS_READ_ONLY_DATABASE
	STATUS_XAPIAN_EXCEPTION
	STATUS_FILE_ERROR
	STATUS_FILE_NOT_EMAIL
	STATUS_DUPLICATE_MESSAGE_ID
	STATUS_NULL_POINTER
	STATUS_TAG_TOO_LONG
	STATUS_UNBALANCED_FREEZE_THAW
	STATUS_UNBALANCED_ATOMIC

	STATUS_LAST_STATUS
)

func (Status) String

func (self Status) String() string

type Tags

type Tags struct {
	// contains filtered or unexported fields
}

func (*Tags) Destroy

func (self *Tags) Destroy()

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 containing message or query objects are destroyed.

func (*Tags) Get

func (self *Tags) Get() 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 ultimately belongs).

See the documentation of notmuch_message_get_tags for example code showing how to iterate over a notmuch_tags_t object.

func (*Tags) MoveToNext

func (self *Tags) MoveToNext()

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.

func (*Tags) String

func (self *Tags) String() string

func (*Tags) Valid

func (self *Tags) Valid() bool

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, 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.

type Thread

type Thread struct {
	// contains filtered or unexported fields
}

func (*Thread) Destroy

func (self *Thread) Destroy()

Destroy a notmuch_thread_t object.

func (*Thread) GetAuthors

func (self *Thread) GetAuthors() string

Get the authors of 'thread' as a UTF-8 string.

The returned string is a comma-separated list of the names of the authors of mail messages in the query results that belong to this thread.

The string contains authors of messages matching the query first, then non-matched authors (with the two groups separated by '|'). Within each group, authors are ordered by date.

The returned string belongs to 'thread' and as such, should not be modified by the caller and will only be valid for as long as the thread is valid, (which is until notmuch_thread_destroy or until the query from which it derived is destroyed).

func (*Thread) GetMatchedMessages

func (self *Thread) GetMatchedMessages() int

Get the number of messages in 'thread' that matched the search.

This count includes only the messages in this thread that were matched by the search from which the thread was created and were not excluded by any exclude tags passed in with the query (see notmuch_query_add_tag_exclude). Contrast with notmuch_thread_get_total_messages().

func (*Thread) GetMessages

func (self *Thread) GetMessages() (*Messages, Status)

Get a notmuch_thread_t iterator for all messages in 'thread' in oldest-first order.

The returned list will be destroyed when the thread is destroyed.

func (*Thread) GetNewestDate

func (self *Thread) GetNewestDate() int64

Get the date of the newest message in 'thread' as a time_t value.

func (*Thread) GetOldestDate

func (self *Thread) GetOldestDate() int64

Get the date of the oldest message in 'thread' as a time_t value.

func (*Thread) GetSubject

func (self *Thread) GetSubject() string

Get the subject of 'thread' as a UTF-8 string.

The subject is taken from the first message (according to the query order---see notmuch_query_set_sort) in the query results that belongs to this thread.

The returned string belongs to 'thread' and as such, should not be modified by the caller and will only be valid for as long as the thread is valid, (which is until notmuch_thread_destroy or until the query from which it derived is destroyed).

func (*Thread) GetTags

func (self *Thread) GetTags() *Tags

Get the tags for 'thread', returning a notmuch_tags_t object which can be used to iterate over all tags.

Note: In the Notmuch database, tags are stored on individual messages, not on threads. So the tags returned here will be all tags of the messages which matched the search and which belong to this thread.

The tags object is owned by the thread and as such, will only be valid for as long as the thread is valid, (for example, until notmuch_thread_destroy or until the query from which it derived is destroyed).

Typical usage might be:

notmuch_thread_t *thread;
notmuch_tags_t *tags;
const char *tag;

thread = notmuch_threads_get (threads);

for (tags = notmuch_thread_get_tags (thread);
     notmuch_tags_valid (tags);
     notmuch_tags_move_to_next (tags))
{
    tag = notmuch_tags_get (tags);
    ....
}

notmuch_thread_destroy (thread);

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).

func (*Thread) GetThreadId

func (self *Thread) GetThreadId() string

Get the thread ID of 'thread'.

The returned string belongs to 'thread' and as such, should not be modified by the caller and will only be valid for as long as the thread is valid, (which is until notmuch_thread_destroy or until the query from which it derived is destroyed).

func (*Thread) GetToplevelMessages

func (self *Thread) GetToplevelMessages() (*Messages, Status)

Get a notmuch_messages_t iterator for the top-level messages in 'thread' in oldest-first order.

This iterator will not necessarily iterate over all of the messages in the thread. It will only iterate over the messages in the thread which are not replies to other messages in the thread.

The returned list will be destroyed when the thread is destroyed.

func (*Thread) GetTotalMessages

func (self *Thread) GetTotalMessages() int

Get the total number of messages in 'thread'.

This count consists of all messages in the database belonging to this thread. Contrast with notmuch_thread_get_matched_messages() .

type Threads

type Threads struct {
	// contains filtered or unexported fields
}

func (*Threads) Destroy

func (self *Threads) Destroy()

Destroy a notmuch_threads_t object.

It's not strictly necessary to call this function. All memory from the notmuch_threads_t object will be reclaimed when the containg query object is destroyed.

func (*Threads) Get

func (self *Threads) Get() *Thread

Get the current thread from 'threads' as a notmuch_thread_t.

Note: The returned thread belongs to 'threads' and has a lifetime identical to it (and the query to which it belongs).

See the documentation of notmuch_query_search_threads for example code showing how to iterate over a notmuch_threads_t object.

If an out-of-memory situation occurs, this function will return NULL.

func (*Threads) MoveToNext

func (self *Threads) MoveToNext()

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.

func (*Threads) Valid

func (self *Threads) Valid() bool

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, 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.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL