This makes notmuch appropriately free the underlying notmuch C objects
when garbage collecting their Go wrappers. To make sure we don't break
the underlying links between objects (for example, a notmuch_messages_t
being GC'ed before a notmuch_message_t belonging to it), we add for each
wraper struct a pointer to the owner object (Go objects with a reference
pointing to them don't get garbage collected).
---
 bindings/go/src/notmuch/notmuch.go |  153 +++++++++++++++++++++++++++++++-----
 1 files changed, 134 insertions(+), 19 deletions(-)

diff --git a/bindings/go/src/notmuch/notmuch.go 
b/bindings/go/src/notmuch/notmuch.go
index 1d77fd2..3f436a0 100644
--- a/bindings/go/src/notmuch/notmuch.go
+++ b/bindings/go/src/notmuch/notmuch.go
@@ -11,6 +11,7 @@ package notmuch
 #include "notmuch.h"
 */
 import "C"
+import "runtime"
 import "unsafe"
 
 // Status codes used for the return values of most functions
@@ -47,40 +48,152 @@ func (self Status) String() string {
 /* Various opaque data types. For each notmuch_<foo>_t see the various
  * notmuch_<foo> functions below. */
 
+type Object interface {}
+
 type Database struct {
        db *C.notmuch_database_t
 }
 
+func createDatabase(db *C.notmuch_database_t) *Database {
+       self := &Database{db: db}
+
+       runtime.SetFinalizer(self, func(x *Database) {
+               if (x.db != nil) {
+                       C.notmuch_database_destroy(x.db)
+               }
+       })
+
+       return self
+}
+
 type Query struct {
        query *C.notmuch_query_t
+       owner Object
+}
+
+func createQuery(query *C.notmuch_query_t, owner Object) *Query {
+       self := &Query{query: query, owner: owner}
+
+       runtime.SetFinalizer(self, func(x *Query) {
+               if (x.query != nil) {
+                       C.notmuch_query_destroy(x.query)
+               }
+       })
+
+       return self
 }
 
 type Threads struct {
        threads *C.notmuch_threads_t
+       owner Object
+}
+
+func createThreads(threads *C.notmuch_threads_t, owner Object) *Threads {
+       self := &Threads{threads: threads, owner: owner}
+
+       runtime.SetFinalizer(self, func(x *Threads) {
+               if (x.threads != nil) {
+                       C.notmuch_threads_destroy(x.threads)
+               }
+       })
+
+       return self
 }
 
 type Thread struct {
        thread *C.notmuch_thread_t
+       owner Object
+}
+
+func createThread(thread *C.notmuch_thread_t, owner Object) *Thread {
+       self := &Thread{thread: thread, owner: owner}
+
+       runtime.SetFinalizer(self, func(x *Thread) {
+               if (x.thread != nil) {
+                       C.notmuch_thread_destroy(x.thread)
+               }
+       })
+
+       return self
 }
 
 type Messages struct {
        messages *C.notmuch_messages_t
+       owner Object
+}
+
+func createMessages(messages *C.notmuch_messages_t, owner Object) *Messages {
+       self := &Messages{messages: messages, owner: owner}
+
+       return self
 }
 
 type Message struct {
        message *C.notmuch_message_t
+       owner Object
+}
+
+func createMessage(message *C.notmuch_message_t, owner Object) *Message {
+       self := &Message{message: message, owner: owner}
+
+       runtime.SetFinalizer(self, func(x *Message) {
+               if (x.message != nil) {
+                       C.notmuch_message_destroy(x.message)
+               }
+       })
+
+       return self
 }
 
 type Tags struct {
        tags *C.notmuch_tags_t
+       owner Object
+}
+
+func createTags(tags *C.notmuch_tags_t, owner Object) *Tags {
+       self := &Tags{tags: tags, owner: owner}
+
+       runtime.SetFinalizer(self, func(x *Tags) {
+               if (x.tags != nil) {
+                       C.notmuch_tags_destroy(x.tags)
+               }
+       })
+
+       return self
 }
 
 type Directory struct {
        dir *C.notmuch_directory_t
+       owner Object
+}
+
+func createDirectory(directory *C.notmuch_directory_t, owner Object) 
*Directory {
+       self := &Directory{dir: directory, owner: owner}
+
+       runtime.SetFinalizer(self, func(x *Directory) {
+               if (x.dir != nil) {
+                       C.notmuch_directory_destroy(x.dir)
+               }
+       })
+
+       return self
 }
 
 type Filenames struct {
        fnames *C.notmuch_filenames_t
+       owner Object
+}
+
+func createFilenames(filenames *C.notmuch_filenames_t, owner Object) 
*Filenames {
+       self := &Filenames{fnames: filenames, owner: owner}
+
+       runtime.SetFinalizer(self, func(x *Filenames) {
+               if (x.fnames != nil) {
+                       C.notmuch_filenames_destroy(x.fnames)
+               }
+       })
+
+       return self
 }
 
 type DatabaseMode C.notmuch_database_mode_t
@@ -100,12 +213,13 @@ func NewDatabase(path string) (*Database, Status) {
                return nil, STATUS_OUT_OF_MEMORY
        }
 
-       self := &Database{db: nil}
-       st := Status(C.notmuch_database_create(c_path, &self.db))
+       var db *C.notmuch_database_t;
+       st := Status(C.notmuch_database_create(c_path, &db))
        if st != STATUS_SUCCESS {
                return nil, st
        }
-       return self, st
+
+       return createDatabase(db), st
 }
 
 /* Open an existing notmuch database located at 'path'.
@@ -134,12 +248,13 @@ func OpenDatabase(path string, mode DatabaseMode) 
(*Database, Status) {
                return nil, STATUS_OUT_OF_MEMORY
        }
 
-       self := &Database{db: nil}
-       st := Status(C.notmuch_database_open(c_path, 
C.notmuch_database_mode_t(mode), &self.db))
+       var db *C.notmuch_database_t;
+       st := Status(C.notmuch_database_open(c_path, 
C.notmuch_database_mode_t(mode), &db))
        if st != STATUS_SUCCESS {
                return nil, st
        }
-       return self, st
+
+       return createDatabase(db), st
 }
 
 /* Close the given notmuch database, freeing all associated
@@ -204,7 +319,7 @@ func (self *Database) GetDirectory(path string) 
(*Directory, Status) {
        if st != STATUS_SUCCESS || c_dir == nil {
                return nil, st
        }
-       return &Directory{dir: c_dir}, st
+       return createDirectory(c_dir, nil), st
 }
 
 /* Add a new message to the given notmuch database.
@@ -258,7 +373,7 @@ func (self *Database) AddMessage(fname string) (*Message, 
Status) {
        var c_msg *C.notmuch_message_t = new(C.notmuch_message_t)
        st := Status(C.notmuch_database_add_message(self.db, c_fname, &c_msg))
 
-       return &Message{message: c_msg}, st
+       return createMessage(c_msg, nil), st
 }
 
 /* Remove a message from the given notmuch database.
@@ -319,12 +434,12 @@ func (self *Database) FindMessage(message_id string) 
(*Message, Status) {
                return nil, STATUS_OUT_OF_MEMORY
        }
 
-       msg := &Message{message: nil}
-       st := Status(C.notmuch_database_find_message(self.db, c_msg_id, 
&msg.message))
+       var msg *C.notmuch_message_t
+       st := Status(C.notmuch_database_find_message(self.db, c_msg_id, &msg))
        if st != STATUS_SUCCESS {
                return nil, st
        }
-       return msg, st
+       return createMessage(msg, nil), st
 }
 
 /* Return a list of all tags found in the database.
@@ -339,7 +454,7 @@ func (self *Database) GetAllTags() *Tags {
        if tags == nil {
                return nil
        }
-       return &Tags{tags: tags}
+       return createTags(tags, nil)
 }
 
 /* Create a new query for 'database'.
@@ -379,7 +494,7 @@ func (self *Database) CreateQuery(query string) *Query {
        if q == nil {
                return nil
        }
-       return &Query{query: q}
+       return createQuery(q, nil)
 }
 
 /* Sort values for notmuch_query_set_sort */
@@ -459,7 +574,7 @@ func (self *Query) SearchThreads() *Threads {
        if threads == nil {
                return nil
        }
-       return &Threads{threads: threads}
+       return createThreads(threads, self)
 }
 
 /* Execute a query for messages, returning a notmuch_messages_t object
@@ -505,7 +620,7 @@ func (self *Query) SearchMessages() *Messages {
        if msgs == nil {
                return nil
        }
-       return &Messages{messages: msgs}
+       return createMessages(msgs, self)
 }
 
 /* Destroy a notmuch_query_t along with any associated resources.
@@ -607,7 +722,7 @@ func (self *Messages) Get() *Message {
        if msg == nil {
                return nil
        }
-       return &Message{message: msg}
+       return createMessage(msg, self)
 }
 
 /* Move the 'messages' iterator to the next message.
@@ -659,7 +774,7 @@ func (self *Messages) CollectTags() *Tags {
        if tags == nil {
                return nil
        }
-       return &Tags{tags: tags}
+       return createTags(tags, self)
 }
 
 /* Get the message ID of 'message'.
@@ -739,7 +854,7 @@ func (self *Message) GetReplies() *Messages {
        if msgs == nil {
                return nil
        }
-       return &Messages{messages: msgs}
+       return createMessages(msgs, self)
 }
 
 /* Get a filename for the email corresponding to 'message'.
@@ -871,7 +986,7 @@ func (self *Message) GetTags() *Tags {
        if tags == nil {
                return nil
        }
-       return &Tags{tags: tags}
+       return createTags(tags, self)
 }
 
 /* The longest possible tag value. */
-- 
1.7.7.6

_______________________________________________
notmuch mailing list
notmuch@notmuchmail.org
http://notmuchmail.org/mailman/listinfo/notmuch

Reply via email to