// 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 }
/** * 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} }