示例#1
0
文件: thread.go 项目: gmuch/gmuch
// Tags returns the tags for the current thread, returning a *Tags which can be
// used to iterate over all tags using `Tags.Next(Tag)`
//
// 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.
func (t *Thread) Tags() *Tags {
	ctags := C.notmuch_thread_get_tags(t.toC())
	tags := &Tags{
		cptr:   unsafe.Pointer(ctags),
		parent: (*cStruct)(t),
	}
	setGcClose(tags)
	return tags
}
示例#2
0
/**
 * 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 (self *Thread) GetTags() *Tags {
	if self.thread == nil {
		return nil
	}

	tags := C.notmuch_thread_get_tags(self.thread)
	if tags == nil {
		return nil
	}

	return &Tags{tags}
}