From c7893408bbe6904ae7da97aa203587af4ec2fac7 Mon Sep 17 00:00:00 2001 From: Ali Polatel Date: Wed, 26 May 2010 18:54:25 +0300 Subject: [PATCH] ruby: Kill garbage collection related cruft. Let the user destroy objects that she wants explicitly. It's not possible to specify the order objects are garbage collected. See id:86y6f8v838.fsf@harikalardiyari.ev on ruby-talk for more information. --- bindings/ruby/database.c | 118 ++++++---------- bindings/ruby/defs.h | 120 ++++------------ bindings/ruby/directory.c | 58 ++++---- bindings/ruby/filenames.c | 28 +++- bindings/ruby/gc.c | 288 -------------------------------------- bindings/ruby/init.c | 8 ++ bindings/ruby/message.c | 138 ++++++++++-------- bindings/ruby/messages.c | 55 ++++---- bindings/ruby/query.c | 60 ++++---- bindings/ruby/tags.c | 30 +++- bindings/ruby/thread.c | 104 ++++++++------ bindings/ruby/threads.c | 38 +++-- 12 files changed, 383 insertions(+), 662 deletions(-) delete mode 100644 bindings/ruby/gc.c diff --git a/bindings/ruby/database.c b/bindings/ruby/database.c index fae5af28..e767819b 100644 --- a/bindings/ruby/database.c +++ b/bindings/ruby/database.c @@ -32,8 +32,8 @@ notmuch_rb_database_new(int argc, VALUE *argv, VALUE klass) { const char *path; int create, mode; - notmuch_rb_database_t *db; - VALUE modev, dbv; + notmuch_database_t *db; + VALUE modev; #if !defined(RSTRING_PTR) #define RSTRING_PTR(v) (RSTRING((v))->ptr) @@ -70,12 +70,11 @@ notmuch_rb_database_new(int argc, VALUE *argv, VALUE klass) mode = NOTMUCH_DATABASE_MODE_READ_ONLY; } - dbv = Data_Make_Struct(klass, notmuch_rb_database_t, NULL, notmuch_rb_database_free, db); - db->nm_db = create ? notmuch_database_create(path) : notmuch_database_open(path, mode); - if (!db->nm_db) + db = create ? notmuch_database_create(path) : notmuch_database_open(path, mode); + if (!db) rb_raise(notmuch_rb_eDatabaseError, "failed to open database"); - return dbv; + return Data_Wrap_Struct(klass, NULL, NULL, db); } /* @@ -86,13 +85,10 @@ notmuch_rb_database_new(int argc, VALUE *argv, VALUE klass) VALUE notmuch_rb_database_close(VALUE self) { - notmuch_rb_database_t *db; + notmuch_database_t *db; - Data_Get_Struct(self, notmuch_rb_database_t, db); - if (db->nm_db) { - notmuch_database_close(db->nm_db); - db->nm_db = NULL; - } + Data_Get_Struct(self, notmuch_database_t, db); + notmuch_database_close(db); return Qnil; } @@ -105,13 +101,11 @@ notmuch_rb_database_close(VALUE self) VALUE notmuch_rb_database_path(VALUE self) { - notmuch_rb_database_t *db; + notmuch_database_t *db; - Data_Get_Struct(self, notmuch_rb_database_t, db); - if (!db->nm_db) - rb_raise(rb_eRuntimeError, "Database closed"); + Data_Get_Struct(self, notmuch_database_t, db); - return rb_str_new2(notmuch_database_get_path(db->nm_db)); + return rb_str_new2(notmuch_database_get_path(db)); } /* @@ -122,13 +116,11 @@ notmuch_rb_database_path(VALUE self) VALUE notmuch_rb_database_version(VALUE self) { - notmuch_rb_database_t *db; + notmuch_database_t *db; - Data_Get_Struct(self, notmuch_rb_database_t, db); - if (!db->nm_db) - rb_raise(rb_eRuntimeError, "Database closed"); + Data_Get_Struct(self, notmuch_database_t, db); - return INT2FIX(notmuch_database_get_version(db->nm_db)); + return INT2FIX(notmuch_database_get_version(db)); } /* @@ -139,13 +131,11 @@ notmuch_rb_database_version(VALUE self) VALUE notmuch_rb_database_needs_upgrade(VALUE self) { - notmuch_rb_database_t *db; + notmuch_database_t *db; - Data_Get_Struct(self, notmuch_rb_database_t, db); - if (!db->nm_db) - rb_raise(rb_eRuntimeError, "Database closed"); + Data_Get_Struct(self, notmuch_database_t, db); - return notmuch_database_needs_upgrade(db->nm_db) ? Qtrue : Qfalse; + return notmuch_database_needs_upgrade(db) ? Qtrue : Qfalse; } static void @@ -168,12 +158,10 @@ notmuch_rb_database_upgrade(VALUE self) { notmuch_status_t ret; void (*pnotify) (void *closure, double progress); - notmuch_rb_database_t *db; + notmuch_database_t *db; VALUE block; - Data_Get_Struct(self, notmuch_rb_database_t, db); - if (!db->nm_db) - rb_raise(rb_eRuntimeError, "Database closed"); + Data_Get_Struct(self, notmuch_database_t, db); if (rb_block_given_p()) { pnotify = notmuch_rb_upgrade_notify; @@ -182,8 +170,9 @@ notmuch_rb_database_upgrade(VALUE self) else pnotify = NULL; - ret = notmuch_database_upgrade(db->nm_db, pnotify, pnotify ? &block : NULL); + ret = notmuch_database_upgrade(db, pnotify, pnotify ? &block : NULL); notmuch_rb_status_raise(ret); + return Qtrue; } @@ -196,13 +185,10 @@ VALUE notmuch_rb_database_get_directory(VALUE self, VALUE pathv) { const char *path; - notmuch_rb_directory_t *dir; - notmuch_rb_database_t *db; - VALUE dirv; + notmuch_directory_t *dir; + notmuch_database_t *db; - Data_Get_Struct(self, notmuch_rb_database_t, db); - if (!db->nm_db) - rb_raise(rb_eRuntimeError, "Database closed"); + Data_Get_Struct(self, notmuch_database_t, db); #if !defined(RSTRING_PTR) #define RSTRING_PTR(v) (RSTRING((v))->ptr) @@ -211,20 +197,18 @@ notmuch_rb_database_get_directory(VALUE self, VALUE pathv) SafeStringValue(pathv); path = RSTRING_PTR(pathv); - dirv = Data_Make_Struct(notmuch_rb_cDirectory, notmuch_rb_directory_t, - notmuch_rb_directory_mark, notmuch_rb_directory_free, dir); - dir->nm_dir = notmuch_database_get_directory(db->nm_db, path); - dir->db = self; - if (!dir->nm_dir) + dir = notmuch_database_get_directory(db, path); + if (!dir) rb_raise(notmuch_rb_eXapianError, "Xapian exception"); - return dirv; + return Data_Wrap_Struct(notmuch_rb_cDirectory, NULL, NULL, dir); } /* * call-seq: DB.add_message(path) => MESSAGE, isdup * - * Add a message to the database and return it + * Add a message to the database and return it. + * * +isdup+ is a boolean that specifies whether the added message was a * duplicate. */ @@ -233,13 +217,10 @@ notmuch_rb_database_add_message(VALUE self, VALUE pathv) { const char *path; notmuch_status_t ret; - notmuch_rb_message_t *message; - notmuch_rb_database_t *db; - VALUE messagev; + notmuch_message_t *message; + notmuch_database_t *db; - Data_Get_Struct(self, notmuch_rb_database_t, db); - if (!db->nm_db) - rb_raise(rb_eRuntimeError, "Database closed"); + Data_Get_Struct(self, notmuch_database_t, db); #if !defined(RSTRING_PTR) #define RSTRING_PTR(v) (RSTRING((v))->ptr) @@ -248,18 +229,17 @@ notmuch_rb_database_add_message(VALUE self, VALUE pathv) SafeStringValue(pathv); path = RSTRING_PTR(pathv); - messagev = Data_Make_Struct(notmuch_rb_cMessage, notmuch_rb_message_t, - notmuch_rb_message_mark, notmuch_rb_message_free, message); - ret = notmuch_database_add_message(db->nm_db, path, &message->nm_message); - message->parent = self; + ret = notmuch_database_add_message(db, path, &message); notmuch_rb_status_raise(ret); - return rb_assoc_new(messagev, (ret == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) ? Qtrue : Qfalse); + return rb_assoc_new(Data_Wrap_Struct(notmuch_rb_cMessage, NULL, NULL, message), + (ret == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) ? Qtrue : Qfalse); } /* * call-seq: DB.remove_message(path) => isdup * * Remove a message from the database. + * * +isdup+ is a boolean that specifies whether the removed message was a * duplicate. */ @@ -268,11 +248,9 @@ notmuch_rb_database_remove_message(VALUE self, VALUE pathv) { const char *path; notmuch_status_t ret; - notmuch_rb_database_t *db; + notmuch_database_t *db; - Data_Get_Struct(self, notmuch_rb_database_t, db); - if (!db->nm_db) - rb_raise(rb_eRuntimeError, "Database closed"); + Data_Get_Struct(self, notmuch_database_t, db); #if !defined(RSTRING_PTR) #define RSTRING_PTR(v) (RSTRING((v))->ptr) @@ -281,7 +259,7 @@ notmuch_rb_database_remove_message(VALUE self, VALUE pathv) SafeStringValue(pathv); path = RSTRING_PTR(pathv); - ret = notmuch_database_remove_message(db->nm_db, path); + ret = notmuch_database_remove_message(db, path); notmuch_rb_status_raise(ret); return (ret == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) ? Qtrue : Qfalse; } @@ -295,13 +273,10 @@ VALUE notmuch_rb_database_query_create(VALUE self, VALUE qstrv) { const char *qstr; - notmuch_rb_query_t *query; - notmuch_rb_database_t *db; - VALUE queryv; + notmuch_query_t *query; + notmuch_database_t *db; - Data_Get_Struct(self, notmuch_rb_database_t, db); - if (!db->nm_db) - rb_raise(rb_eRuntimeError, "Database closed"); + Data_Get_Struct(self, notmuch_database_t, db); #if !defined(RSTRING_PTR) #define RSTRING_PTR(v) (RSTRING((v))->ptr) @@ -310,12 +285,9 @@ notmuch_rb_database_query_create(VALUE self, VALUE qstrv) SafeStringValue(qstrv); qstr = RSTRING_PTR(qstrv); - queryv = Data_Make_Struct(notmuch_rb_cQuery, notmuch_rb_query_t, - notmuch_rb_query_mark, notmuch_rb_query_free, query); - query->nm_query = notmuch_query_create(db->nm_db, qstr); - query->db = self; - if (!query->nm_query) + query = notmuch_query_create(db, qstr); + if (!query) rb_raise(notmuch_rb_eMemoryError, "out of memory"); - return queryv; + return Data_Wrap_Struct(notmuch_rb_cQuery, NULL, NULL, query); } diff --git a/bindings/ruby/defs.h b/bindings/ruby/defs.h index 1973d26e..f36b7227 100644 --- a/bindings/ruby/defs.h +++ b/bindings/ruby/defs.h @@ -49,106 +49,10 @@ ID ID_call; ID ID_db_create; ID ID_db_mode; -typedef struct { - notmuch_database_t *nm_db; -} notmuch_rb_database_t; - -typedef struct { - notmuch_directory_t *nm_dir; - VALUE db; -} notmuch_rb_directory_t; - -typedef struct { - notmuch_filenames_t *nm_flist; - VALUE dir; -} notmuch_rb_filenames_t; - -typedef struct { - notmuch_query_t *nm_query; - VALUE db; -} notmuch_rb_query_t; - -typedef struct { - notmuch_threads_t *nm_threads; - VALUE query; -} notmuch_rb_threads_t; - -typedef struct { - notmuch_messages_t *nm_messages; - VALUE parent; -} notmuch_rb_messages_t; - -typedef struct { - notmuch_thread_t *nm_thread; - VALUE threads; -} notmuch_rb_thread_t; - -typedef struct { - notmuch_message_t *nm_message; - VALUE parent; -} notmuch_rb_message_t; - -typedef struct { - notmuch_tags_t *nm_tags; - VALUE parent; -} notmuch_rb_tags_t; - /* status.c */ void notmuch_rb_status_raise(notmuch_status_t status); -/* gc.c */ -void -notmuch_rb_database_free(notmuch_rb_database_t *db); - -void -notmuch_rb_directory_mark(notmuch_rb_directory_t *dir); - -void -notmuch_rb_directory_free(notmuch_rb_directory_t *dir); - -void -notmuch_rb_filenames_mark(notmuch_rb_filenames_t *flist); - -void -notmuch_rb_filenames_free(notmuch_rb_filenames_t *flist); - -void -notmuch_rb_query_mark(notmuch_rb_query_t *query); - -void -notmuch_rb_query_free(notmuch_rb_query_t *query); - -void -notmuch_rb_threads_mark(notmuch_rb_threads_t *threads); - -void -notmuch_rb_threads_free(notmuch_rb_threads_t *threads); - -void -notmuch_rb_messages_mark(notmuch_rb_messages_t *messages); - -void -notmuch_rb_messages_free(notmuch_rb_messages_t *messages); - -void -notmuch_rb_thread_mark(notmuch_rb_thread_t *thread); - -void -notmuch_rb_thread_free(notmuch_rb_thread_t *thread); - -void -notmuch_rb_message_mark(notmuch_rb_message_t *message); - -void -notmuch_rb_message_free(notmuch_rb_message_t *message); - -void -notmuch_rb_tags_mark(notmuch_rb_tags_t *tags); - -void -notmuch_rb_tags_free(notmuch_rb_tags_t *tags); - /* database.c */ VALUE notmuch_rb_database_new(int argc, VALUE *argv, VALUE klass); @@ -181,6 +85,9 @@ VALUE notmuch_rb_database_query_create(VALUE self, VALUE qstrv); /* directory.c */ +VALUE +notmuch_rb_directory_destroy(VALUE self); + VALUE notmuch_rb_directory_get_mtime(VALUE self); @@ -194,10 +101,16 @@ VALUE notmuch_rb_directory_get_child_directories(VALUE self); /* filenames.c */ +VALUE +notmuch_rb_filenames_destroy(VALUE self); + VALUE notmuch_rb_filenames_each(VALUE self); /* query.c */ +VALUE +notmuch_rb_query_destroy(VALUE self); + VALUE notmuch_rb_query_set_sort(VALUE self, VALUE sortv); @@ -208,10 +121,16 @@ VALUE notmuch_rb_query_search_messages(VALUE self); /* threads.c */ +VALUE +notmuch_rb_threads_destroy(VALUE self); + VALUE notmuch_rb_threads_each(VALUE self); /* messages.c */ +VALUE +notmuch_rb_messages_destroy(VALUE self); + VALUE notmuch_rb_messages_each(VALUE self); @@ -219,6 +138,9 @@ VALUE notmuch_rb_messages_collect_tags(VALUE self); /* thread.c */ +VALUE +notmuch_rb_thread_destroy(VALUE self); + VALUE notmuch_rb_thread_get_thread_id(VALUE self); @@ -247,6 +169,9 @@ VALUE notmuch_rb_thread_get_tags(VALUE self); /* message.c */ +VALUE +notmuch_rb_message_destroy(VALUE self); + VALUE notmuch_rb_message_get_message_id(VALUE self); @@ -290,6 +215,9 @@ VALUE notmuch_rb_message_thaw(VALUE self); /* tags.c */ +VALUE +notmuch_rb_tags_destroy(VALUE self); + VALUE notmuch_rb_tags_each(VALUE self); diff --git a/bindings/ruby/directory.c b/bindings/ruby/directory.c index 46fe11cf..e73658c1 100644 --- a/bindings/ruby/directory.c +++ b/bindings/ruby/directory.c @@ -20,6 +20,23 @@ #include "defs.h" +/* + * call-seq: DIR.destroy => nil + * + * Destroys the directory, freeing all resources allocated for it. + */ +VALUE +notmuch_rb_directory_destroy(VALUE self) +{ + notmuch_directory_t *dir; + + Data_Get_Struct(self, notmuch_directory_t, dir); + + notmuch_directory_destroy(dir); + + return Qnil; +} + /* * call-seq: DIR.mtime => fixnum * @@ -29,11 +46,11 @@ VALUE notmuch_rb_directory_get_mtime(VALUE self) { - notmuch_rb_directory_t *dir; + notmuch_directory_t *dir; - Data_Get_Struct(self, notmuch_rb_directory_t, dir); + Data_Get_Struct(self, notmuch_directory_t, dir); - return UINT2NUM(notmuch_directory_get_mtime(dir->nm_dir)); + return UINT2NUM(notmuch_directory_get_mtime(dir)); } /* @@ -45,15 +62,16 @@ VALUE notmuch_rb_directory_set_mtime(VALUE self, VALUE mtimev) { notmuch_status_t ret; - notmuch_rb_directory_t *dir; + notmuch_directory_t *dir; - Data_Get_Struct(self, notmuch_rb_directory_t, dir); + Data_Get_Struct(self, notmuch_directory_t, dir); if (!FIXNUM_P(mtimev)) rb_raise(rb_eTypeError, "First argument not a fixnum"); - ret = notmuch_directory_set_mtime(dir->nm_dir, FIX2UINT(mtimev)); + ret = notmuch_directory_set_mtime(dir, FIX2UINT(mtimev)); notmuch_rb_status_raise(ret); + return Qtrue; } @@ -66,18 +84,14 @@ notmuch_rb_directory_set_mtime(VALUE self, VALUE mtimev) VALUE notmuch_rb_directory_get_child_files(VALUE self) { - notmuch_rb_directory_t *dir; - notmuch_rb_filenames_t *flist; - VALUE flistv; + notmuch_directory_t *dir; + notmuch_filenames_t *fnames; - Data_Get_Struct(self, notmuch_rb_directory_t, dir); + Data_Get_Struct(self, notmuch_directory_t, dir); - flistv = Data_Make_Struct(notmuch_rb_cFileNames, notmuch_rb_filenames_t, - notmuch_rb_filenames_mark, notmuch_rb_filenames_free, flist); - flist->dir = self; - flist->nm_flist = notmuch_directory_get_child_files(dir->nm_dir); + fnames = notmuch_directory_get_child_files(dir); - return flistv; + return Data_Wrap_Struct(notmuch_rb_cFileNames, NULL, NULL, fnames); } /* @@ -89,16 +103,12 @@ notmuch_rb_directory_get_child_files(VALUE self) VALUE notmuch_rb_directory_get_child_directories(VALUE self) { - notmuch_rb_directory_t *dir; - notmuch_rb_filenames_t *flist; - VALUE flistv; + notmuch_directory_t *dir; + notmuch_filenames_t *fnames; - Data_Get_Struct(self, notmuch_rb_directory_t, dir); + Data_Get_Struct(self, notmuch_directory_t, dir); - flistv = Data_Make_Struct(notmuch_rb_cFileNames, notmuch_rb_filenames_t, - notmuch_rb_filenames_mark, notmuch_rb_filenames_free, flist); - flist->dir = self; - flist->nm_flist = notmuch_directory_get_child_directories(dir->nm_dir); + fnames = notmuch_directory_get_child_directories(dir); - return flistv; + return Data_Wrap_Struct(notmuch_rb_cFileNames, NULL, NULL, fnames); } diff --git a/bindings/ruby/filenames.c b/bindings/ruby/filenames.c index 44a16522..23553ab1 100644 --- a/bindings/ruby/filenames.c +++ b/bindings/ruby/filenames.c @@ -20,6 +20,23 @@ #include "defs.h" +/* + * call-seq: FILENAMES.destroy => nil + * + * Destroys the filenames, freeing all resources allocated for it. + */ +VALUE +notmuch_rb_filenames_destroy(VALUE self) +{ + notmuch_filenames_t *fnames; + + Data_Get_Struct(self, notmuch_filenames_t, fnames); + + notmuch_filenames_destroy(fnames); + + return Qnil; +} + /* * call-seq: FILENAMES.each {|item| block } => FILENAMES * @@ -29,15 +46,14 @@ VALUE notmuch_rb_filenames_each(VALUE self) { - notmuch_rb_filenames_t *flist; + notmuch_filenames_t *fnames; - Data_Get_Struct(self, notmuch_rb_filenames_t, flist); - if (!flist->nm_flist) + Data_Get_Struct(self, notmuch_filenames_t, fnames); + if (!fnames) return self; - for (; notmuch_filenames_valid(flist->nm_flist); - notmuch_filenames_move_to_next(flist->nm_flist)) - rb_yield(rb_str_new2(notmuch_filenames_get(flist->nm_flist))); + for (; notmuch_filenames_valid(fnames); notmuch_filenames_move_to_next(fnames)) + rb_yield(rb_str_new2(notmuch_filenames_get(fnames))); return self; } diff --git a/bindings/ruby/gc.c b/bindings/ruby/gc.c deleted file mode 100644 index 37b089f4..00000000 --- a/bindings/ruby/gc.c +++ /dev/null @@ -1,288 +0,0 @@ -/* The Ruby interface to the notmuch mail library - * - * Copyright © 2010 Ali Polatel - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see http://www.gnu.org/licenses/ . - * - * Author: Ali Polatel - */ - -#include "defs.h" - -#include - -static notmuch_rb_database_t * -_notmuch_rb_messages_db(notmuch_rb_messages_t *messages); - -static notmuch_rb_database_t * -_notmuch_rb_message_db(notmuch_rb_message_t *message) -{ - notmuch_rb_messages_t *messages; - notmuch_rb_database_t *db; - - if (rb_obj_is_instance_of(message->parent, notmuch_rb_cDatabase)) { - Data_Get_Struct(message->parent, notmuch_rb_database_t, db); - } - else if (rb_obj_is_instance_of(message->parent, notmuch_rb_cMessages)) { - Data_Get_Struct(message->parent, notmuch_rb_messages_t, messages); - db = _notmuch_rb_messages_db(messages); - } - else - db = NULL; - - return db; -} - -static notmuch_rb_database_t * -_notmuch_rb_messages_db(notmuch_rb_messages_t *messages) -{ - notmuch_rb_query_t *query; - notmuch_rb_thread_t *thread; - notmuch_rb_message_t *message; - notmuch_rb_threads_t *threads; - notmuch_rb_database_t *db; - - if (rb_obj_is_instance_of(messages->parent, notmuch_rb_cQuery)) { - Data_Get_Struct(messages->parent, notmuch_rb_query_t, query); - Data_Get_Struct(query->db, notmuch_rb_database_t, db); - } - else if (rb_obj_is_instance_of(messages->parent, notmuch_rb_cThread)) { - Data_Get_Struct(messages->parent, notmuch_rb_thread_t, thread); - Data_Get_Struct(thread->threads, notmuch_rb_threads_t, threads); - Data_Get_Struct(threads->query, notmuch_rb_query_t, query); - Data_Get_Struct(query->db, notmuch_rb_database_t, db); - } - else if (rb_obj_is_instance_of(messages->parent, notmuch_rb_cMessage)) { - Data_Get_Struct(messages->parent, notmuch_rb_message_t, message); - db = _notmuch_rb_message_db(message); - } - else - db = NULL; - - return db; -} - -static notmuch_rb_database_t * -_notmuch_rb_thread_db(notmuch_rb_thread_t *thread) -{ - notmuch_rb_threads_t *threads; - notmuch_rb_query_t *query; - notmuch_rb_database_t *db; - - Data_Get_Struct(thread->threads, notmuch_rb_threads_t, threads); - Data_Get_Struct(threads->query, notmuch_rb_query_t, query); - Data_Get_Struct(query->db, notmuch_rb_database_t, db); - - return db; -} - -void -notmuch_rb_database_free(notmuch_rb_database_t *db) -{ - if (db->nm_db) - notmuch_database_close(db->nm_db); - - free(db); -} - -void -notmuch_rb_directory_mark(notmuch_rb_directory_t *dir) -{ - rb_gc_mark(dir->db); -} - -void -notmuch_rb_directory_free(notmuch_rb_directory_t *dir) -{ - notmuch_rb_database_t *db; - - if (rb_obj_is_instance_of(dir->db, notmuch_rb_cDatabase)) - Data_Get_Struct(dir->db, notmuch_rb_database_t, db); - else - db = NULL; - - if (db && db->nm_db && dir->nm_dir) - notmuch_directory_destroy(dir->nm_dir); - - free(dir); -} - -void -notmuch_rb_filenames_mark(notmuch_rb_filenames_t *flist) -{ - rb_gc_mark(flist->dir); -} - -void -notmuch_rb_filenames_free(notmuch_rb_filenames_t *flist) -{ - notmuch_rb_directory_t *dir; - notmuch_rb_database_t *db; - - if (rb_obj_is_instance_of(flist->dir, notmuch_rb_cDirectory)) { - Data_Get_Struct(flist->dir, notmuch_rb_directory_t, dir); - if (rb_obj_is_instance_of(dir->db, notmuch_rb_cDatabase)) - Data_Get_Struct(dir->db, notmuch_rb_database_t, db); - else - db = NULL; - } - else - db = NULL; - - if (db && db->nm_db && flist->nm_flist) - notmuch_filenames_destroy(flist->nm_flist); - - free(flist); -} - -void -notmuch_rb_query_mark(notmuch_rb_query_t *query) -{ - rb_gc_mark(query->db); -} - -void -notmuch_rb_query_free(notmuch_rb_query_t *query) -{ - notmuch_rb_database_t *db; - - if (rb_obj_is_instance_of(query->db, notmuch_rb_cDatabase)) - Data_Get_Struct(query->db, notmuch_rb_database_t, db); - else - db = NULL; - - if (db && db->nm_db && query->nm_query) - notmuch_query_destroy(query->nm_query); - - free(query); -} - -void -notmuch_rb_threads_mark(notmuch_rb_threads_t *threads) -{ - rb_gc_mark(threads->query); -} - -void -notmuch_rb_threads_free(notmuch_rb_threads_t *threads) -{ - notmuch_rb_query_t *query; - notmuch_rb_database_t *db; - - if (rb_obj_is_instance_of(threads->query, notmuch_rb_cQuery)) { - Data_Get_Struct(threads->query, notmuch_rb_query_t, query); - if (rb_obj_is_instance_of(query->db, notmuch_rb_cDatabase)) - Data_Get_Struct(query->db, notmuch_rb_database_t, db); - else - db = NULL; - } - else - db = NULL; - - if (db && db->nm_db && threads->nm_threads) - notmuch_threads_destroy(threads->nm_threads); - - free(threads); -} - -void -notmuch_rb_messages_mark(notmuch_rb_messages_t *messages) -{ - rb_gc_mark(messages->parent); -} - -void -notmuch_rb_messages_free(notmuch_rb_messages_t *messages) -{ - notmuch_rb_database_t *db; - - db = _notmuch_rb_messages_db(messages); - - if (db && db->nm_db && messages->nm_messages) - notmuch_messages_destroy(messages->nm_messages); - - free(messages); -} - -void -notmuch_rb_thread_mark(notmuch_rb_thread_t *thread) -{ - rb_gc_mark(thread->threads); -} - -void -notmuch_rb_thread_free(notmuch_rb_thread_t *thread) -{ - notmuch_rb_database_t *db; - - db = _notmuch_rb_thread_db(thread); - - if (db && db->nm_db && thread->nm_thread) - notmuch_thread_destroy(thread->nm_thread); - - free(thread); -} - -void -notmuch_rb_message_mark(notmuch_rb_message_t *message) -{ - rb_gc_mark(message->parent); -} - -void -notmuch_rb_message_free(notmuch_rb_message_t *message) -{ - notmuch_rb_database_t *db; - - db = _notmuch_rb_message_db(message); - if (db && db->nm_db && message->nm_message) - notmuch_message_destroy(message->nm_message); - - free(message); -} - -void -notmuch_rb_tags_mark(notmuch_rb_tags_t *tags) -{ - rb_gc_mark(tags->parent); -} - -void -notmuch_rb_tags_free(notmuch_rb_tags_t *tags) -{ - notmuch_rb_message_t *message; - notmuch_rb_messages_t *messages; - notmuch_rb_thread_t *thread; - notmuch_rb_database_t *db; - - if (rb_obj_is_instance_of(tags->parent, notmuch_rb_cThread)) { - Data_Get_Struct(tags->parent, notmuch_rb_thread_t, thread); - db = _notmuch_rb_thread_db(thread); - } - else if (rb_obj_is_instance_of(tags->parent, notmuch_rb_cMessage)) { - Data_Get_Struct(tags->parent, notmuch_rb_message_t, message); - db = _notmuch_rb_message_db(message); - } - else if (rb_obj_is_instance_of(tags->parent, notmuch_rb_cMessages)) { - Data_Get_Struct(tags->parent, notmuch_rb_messages_t, messages); - db = _notmuch_rb_messages_db(messages); - } - else - return; - - if (db && db->nm_db && tags->nm_tags) - notmuch_tags_destroy(tags->nm_tags); - - free(tags); -} diff --git a/bindings/ruby/init.c b/bindings/ruby/init.c index 61077ccb..4fdd018c 100644 --- a/bindings/ruby/init.c +++ b/bindings/ruby/init.c @@ -207,6 +207,7 @@ Init_notmuch(void) notmuch_rb_cDirectory = rb_define_class_under(mod, "Directory", rb_cObject); rb_undef_method(notmuch_rb_cDirectory, "initialize"); + rb_define_method(notmuch_rb_cDirectory, "destroy", notmuch_rb_directory_destroy, 0); rb_define_method(notmuch_rb_cDirectory, "mtime", notmuch_rb_directory_get_mtime, 0); rb_define_method(notmuch_rb_cDirectory, "mtime=", notmuch_rb_directory_set_mtime, 1); rb_define_method(notmuch_rb_cDirectory, "child_files", notmuch_rb_directory_get_child_files, 0); @@ -214,28 +215,33 @@ Init_notmuch(void) notmuch_rb_cFileNames = rb_define_class_under(mod, "FileNames", rb_cObject); rb_undef_method(notmuch_rb_cFileNames, "initialize"); + rb_define_method(notmuch_rb_cFileNames, "destroy", notmuch_rb_filenames_destroy, 0); rb_define_method(notmuch_rb_cFileNames, "each", notmuch_rb_filenames_each, 0); rb_include_module(notmuch_rb_cFileNames, rb_mEnumerable); notmuch_rb_cQuery = rb_define_class_under(mod, "Query", rb_cObject); rb_undef_method(notmuch_rb_cQuery, "initialize"); + rb_define_method(notmuch_rb_cQuery, "destroy", notmuch_rb_query_destroy, 0); rb_define_method(notmuch_rb_cQuery, "sort=", notmuch_rb_query_set_sort, 1); rb_define_method(notmuch_rb_cQuery, "search_threads", notmuch_rb_query_search_threads, 0); rb_define_method(notmuch_rb_cQuery, "search_messages", notmuch_rb_query_search_messages, 0); notmuch_rb_cThreads = rb_define_class_under(mod, "Threads", rb_cObject); rb_undef_method(notmuch_rb_cThreads, "initialize"); + rb_define_method(notmuch_rb_cThreads, "destroy", notmuch_rb_threads_destroy, 0); rb_define_method(notmuch_rb_cThreads, "each", notmuch_rb_threads_each, 0); rb_include_module(notmuch_rb_cThreads, rb_mEnumerable); notmuch_rb_cMessages = rb_define_class_under(mod, "Messages", rb_cObject); rb_undef_method(notmuch_rb_cMessages, "initialize"); + rb_define_method(notmuch_rb_cMessages, "destroy", notmuch_rb_messages_destroy, 0); rb_define_method(notmuch_rb_cMessages, "each", notmuch_rb_messages_each, 0); rb_define_method(notmuch_rb_cMessages, "tags", notmuch_rb_messages_collect_tags, 0); rb_include_module(notmuch_rb_cMessages, rb_mEnumerable); notmuch_rb_cThread = rb_define_class_under(mod, "Thread", rb_cObject); rb_undef_method(notmuch_rb_cThread, "initialize"); + rb_define_method(notmuch_rb_cThread, "destroy", notmuch_rb_thread_destroy, 0); rb_define_method(notmuch_rb_cThread, "thread_id", notmuch_rb_thread_get_thread_id, 0); rb_define_method(notmuch_rb_cThread, "total_messages", notmuch_rb_thread_get_total_messages, 0); rb_define_method(notmuch_rb_cThread, "toplevel_messages", notmuch_rb_thread_get_toplevel_messages, 0); @@ -248,6 +254,7 @@ Init_notmuch(void) notmuch_rb_cMessage = rb_define_class_under(mod, "Message", rb_cObject); rb_undef_method(notmuch_rb_cMessage, "initialize"); + rb_define_method(notmuch_rb_cMessage, "destroy", notmuch_rb_message_destroy, 0); rb_define_method(notmuch_rb_cMessage, "message_id", notmuch_rb_message_get_message_id, 0); rb_define_method(notmuch_rb_cMessage, "thread_id", notmuch_rb_message_get_thread_id, 0); rb_define_method(notmuch_rb_cMessage, "replies", notmuch_rb_message_get_replies, 0); @@ -267,6 +274,7 @@ Init_notmuch(void) notmuch_rb_cTags = rb_define_class_under(mod, "Tags", rb_cObject); rb_undef_method(notmuch_rb_cTags, "initialize"); + rb_define_method(notmuch_rb_cTags, "destroy", notmuch_rb_tags_destroy, 0); rb_define_method(notmuch_rb_cTags, "each", notmuch_rb_tags_each, 0); rb_include_module(notmuch_rb_cTags, rb_mEnumerable); } diff --git a/bindings/ruby/message.c b/bindings/ruby/message.c index 6c7a0391..2babfd04 100644 --- a/bindings/ruby/message.c +++ b/bindings/ruby/message.c @@ -20,6 +20,23 @@ #include "defs.h" +/* + * call-seq: MESSAGE.destroy => nil + * + * Destroys the message, freeing all resources allocated for it. + */ +VALUE +notmuch_rb_message_destroy(VALUE self) +{ + notmuch_message_t *message; + + Data_Get_Struct(self, notmuch_message_t, message); + + notmuch_message_destroy(message); + + return Qnil; +} + /* * call-seq: MESSAGE.message_id => String * @@ -29,12 +46,13 @@ VALUE notmuch_rb_message_get_message_id(VALUE self) { const char *msgid; - notmuch_rb_message_t *message; + notmuch_message_t *message; + + Data_Get_Struct(self, notmuch_message_t, message); - Data_Get_Struct(self, notmuch_rb_message_t, message); + msgid = notmuch_message_get_message_id(message); - msgid = notmuch_message_get_message_id(message->nm_message); - return msgid ? rb_str_new2(msgid) : Qnil; + return rb_str_new2(msgid); } /* @@ -46,12 +64,13 @@ VALUE notmuch_rb_message_get_thread_id(VALUE self) { const char *tid; - notmuch_rb_message_t *message; + notmuch_message_t *message; + + Data_Get_Struct(self, notmuch_message_t, message); - Data_Get_Struct(self, notmuch_rb_message_t, message); + tid = notmuch_message_get_thread_id(message); - tid = notmuch_message_get_thread_id(message->nm_message); - return tid ? rb_str_new2(tid) : Qnil; + return rb_str_new2(tid); } /* @@ -62,18 +81,14 @@ notmuch_rb_message_get_thread_id(VALUE self) VALUE notmuch_rb_message_get_replies(VALUE self) { - notmuch_rb_messages_t *messages; - notmuch_rb_message_t *message; - VALUE messagesv; + notmuch_messages_t *messages; + notmuch_message_t *message; - Data_Get_Struct(self, notmuch_rb_message_t, message); + Data_Get_Struct(self, notmuch_message_t, message); - messagesv = Data_Make_Struct(notmuch_rb_cMessages, notmuch_rb_messages_t, - notmuch_rb_messages_mark, notmuch_rb_messages_free, messages); - messages->nm_messages = notmuch_message_get_replies(message->nm_message); - messages->parent = self; + messages = notmuch_message_get_replies(message); - return messages->nm_messages ? messagesv : Qnil; + return Data_Wrap_Struct(notmuch_rb_cMessages, NULL, NULL, messages); } /* @@ -85,12 +100,13 @@ VALUE notmuch_rb_message_get_filename(VALUE self) { const char *fname; - notmuch_rb_message_t *message; + notmuch_message_t *message; - Data_Get_Struct(self, notmuch_rb_message_t, message); + Data_Get_Struct(self, notmuch_message_t, message); - fname = notmuch_message_get_filename(message->nm_message); - return fname ? rb_str_new2(fname) : Qnil; + fname = notmuch_message_get_filename(message); + + return rb_str_new2(fname); } /* @@ -101,14 +117,14 @@ notmuch_rb_message_get_filename(VALUE self) VALUE notmuch_rb_message_get_flag(VALUE self, VALUE flagv) { - notmuch_rb_message_t *message; + notmuch_message_t *message; - Data_Get_Struct(self, notmuch_rb_message_t, message); + Data_Get_Struct(self, notmuch_message_t, message); if (!FIXNUM_P(flagv)) rb_raise(rb_eTypeError, "Flag not a Fixnum"); - return notmuch_message_get_flag(message->nm_message, FIX2INT(flagv)) ? Qtrue : Qfalse; + return notmuch_message_get_flag(message, FIX2INT(flagv)) ? Qtrue : Qfalse; } /* @@ -119,14 +135,15 @@ notmuch_rb_message_get_flag(VALUE self, VALUE flagv) VALUE notmuch_rb_message_set_flag(VALUE self, VALUE flagv, VALUE valuev) { - notmuch_rb_message_t *message; + notmuch_message_t *message; - Data_Get_Struct(self, notmuch_rb_message_t, message); + Data_Get_Struct(self, notmuch_message_t, message); if (!FIXNUM_P(flagv)) rb_raise(rb_eTypeError, "Flag not a Fixnum"); - notmuch_message_set_flag(message->nm_message, FIX2INT(flagv), RTEST(valuev)); + notmuch_message_set_flag(message, FIX2INT(flagv), RTEST(valuev)); + return Qnil; } @@ -138,11 +155,11 @@ notmuch_rb_message_set_flag(VALUE self, VALUE flagv, VALUE valuev) VALUE notmuch_rb_message_get_date(VALUE self) { - notmuch_rb_message_t *message; + notmuch_message_t *message; - Data_Get_Struct(self, notmuch_rb_message_t, message); + Data_Get_Struct(self, notmuch_message_t, message); - return UINT2NUM(notmuch_message_get_date(message->nm_message)); + return UINT2NUM(notmuch_message_get_date(message)); } /* @@ -154,9 +171,9 @@ VALUE notmuch_rb_message_get_header(VALUE self, VALUE headerv) { const char *header, *value; - notmuch_rb_message_t *message; + notmuch_message_t *message; - Data_Get_Struct(self, notmuch_rb_message_t, message); + Data_Get_Struct(self, notmuch_message_t, message); #if !defined(RSTRING_PTR) #define RSTRING_PTR(v) (RSTRING((v))->ptr) @@ -165,9 +182,9 @@ notmuch_rb_message_get_header(VALUE self, VALUE headerv) SafeStringValue(headerv); header = RSTRING_PTR(headerv); - value = notmuch_message_get_header(message->nm_message, header); + value = notmuch_message_get_header(message, header); if (!value) - rb_raise(notmuch_rb_eMemoryError, "out of memory"); + rb_raise(notmuch_rb_eMemoryError, "Out of memory"); return rb_str_new2(value); } @@ -180,20 +197,16 @@ notmuch_rb_message_get_header(VALUE self, VALUE headerv) VALUE notmuch_rb_message_get_tags(VALUE self) { - notmuch_rb_message_t *message; - notmuch_rb_tags_t *tags; - VALUE tagsv; + notmuch_message_t *message; + notmuch_tags_t *tags; - Data_Get_Struct(self, notmuch_rb_message_t, message); + Data_Get_Struct(self, notmuch_message_t, message); - tagsv = Data_Make_Struct(notmuch_rb_cTags, notmuch_rb_tags_t, - notmuch_rb_tags_mark, notmuch_rb_tags_free, tags); - tags->nm_tags = notmuch_message_get_tags(message->nm_message); - tags->parent = self; - if (!tags->nm_tags) - rb_raise(notmuch_rb_eMemoryError, "out of memory"); + tags = notmuch_message_get_tags(message); + if (!tags) + rb_raise(notmuch_rb_eMemoryError, "Out of memory"); - return tagsv; + return Data_Wrap_Struct(notmuch_rb_cTags, NULL, NULL, tags); } /* @@ -206,9 +219,9 @@ notmuch_rb_message_add_tag(VALUE self, VALUE tagv) { const char *tag; notmuch_status_t ret; - notmuch_rb_message_t *message; + notmuch_message_t *message; - Data_Get_Struct(self, notmuch_rb_message_t, message); + Data_Get_Struct(self, notmuch_message_t, message); #if !defined(RSTRING_PTR) #define RSTRING_PTR(v) (RSTRING((v))->ptr) @@ -217,8 +230,9 @@ notmuch_rb_message_add_tag(VALUE self, VALUE tagv) SafeStringValue(tagv); tag = RSTRING_PTR(tagv); - ret = notmuch_message_add_tag(message->nm_message, tag); + ret = notmuch_message_add_tag(message, tag); notmuch_rb_status_raise(ret); + return Qtrue; } @@ -232,9 +246,9 @@ notmuch_rb_message_remove_tag(VALUE self, VALUE tagv) { const char *tag; notmuch_status_t ret; - notmuch_rb_message_t *message; + notmuch_message_t *message; - Data_Get_Struct(self, notmuch_rb_message_t, message); + Data_Get_Struct(self, notmuch_message_t, message); #if !defined(RSTRING_PTR) #define RSTRING_PTR(v) (RSTRING((v))->ptr) @@ -243,8 +257,9 @@ notmuch_rb_message_remove_tag(VALUE self, VALUE tagv) SafeStringValue(tagv); tag = RSTRING_PTR(tagv); - ret = notmuch_message_remove_tag(message->nm_message, tag); + ret = notmuch_message_remove_tag(message, tag); notmuch_rb_status_raise(ret); + return Qtrue; } @@ -257,12 +272,13 @@ VALUE notmuch_rb_message_remove_all_tags(VALUE self) { notmuch_status_t ret; - notmuch_rb_message_t *message; + notmuch_message_t *message; - Data_Get_Struct(self, notmuch_rb_message_t, message); + Data_Get_Struct(self, notmuch_message_t, message); - ret = notmuch_message_remove_all_tags(message->nm_message); + ret = notmuch_message_remove_all_tags(message); notmuch_rb_status_raise(ret); + return Qtrue; } @@ -275,12 +291,13 @@ VALUE notmuch_rb_message_freeze(VALUE self) { notmuch_status_t ret; - notmuch_rb_message_t *message; + notmuch_message_t *message; - Data_Get_Struct(self, notmuch_rb_message_t, message); + Data_Get_Struct(self, notmuch_message_t, message); - ret = notmuch_message_freeze(message->nm_message); + ret = notmuch_message_freeze(message); notmuch_rb_status_raise(ret); + return Qtrue; } @@ -293,11 +310,12 @@ VALUE notmuch_rb_message_thaw(VALUE self) { notmuch_status_t ret; - notmuch_rb_message_t *message; + notmuch_message_t *message; - Data_Get_Struct(self, notmuch_rb_message_t, message); + Data_Get_Struct(self, notmuch_message_t, message); - ret = notmuch_message_thaw(message->nm_message); + ret = notmuch_message_thaw(message); notmuch_rb_status_raise(ret); + return Qtrue; } diff --git a/bindings/ruby/messages.c b/bindings/ruby/messages.c index 6b296b32..94b0b0da 100644 --- a/bindings/ruby/messages.c +++ b/bindings/ruby/messages.c @@ -20,6 +20,23 @@ #include "defs.h" +/* + * call-seq: MESSAGES.destroy => nil + * + * Destroys the messages, freeing all resources allocated for it. + */ +VALUE +notmuch_rb_messages_destroy(VALUE self) +{ + notmuch_messages_t *fnames; + + Data_Get_Struct(self, notmuch_messages_t, fnames); + + notmuch_messages_destroy(fnames); + + return Qnil; +} + /* call-seq: MESSAGES.each {|item| block } => MESSAGES * * Calls +block+ once for each message in +self+, passing that element as a @@ -28,22 +45,16 @@ VALUE notmuch_rb_messages_each(VALUE self) { - notmuch_rb_message_t *message; - notmuch_rb_messages_t *messages; - VALUE messagev; + notmuch_message_t *message; + notmuch_messages_t *messages; - Data_Get_Struct(self, notmuch_rb_messages_t, messages); - if (!messages->nm_messages) + Data_Get_Struct(self, notmuch_messages_t, messages); + if (!messages) return self; - for (; notmuch_messages_valid(messages->nm_messages); - notmuch_messages_move_to_next(messages->nm_messages)) - { - messagev = Data_Make_Struct(notmuch_rb_cMessage, notmuch_rb_message_t, - notmuch_rb_message_mark, notmuch_rb_message_free, message); - message->nm_message = notmuch_messages_get(messages->nm_messages); - message->parent = self; - rb_yield(messagev); + for (; notmuch_messages_valid(messages); notmuch_messages_move_to_next(messages)) { + message = notmuch_messages_get(messages); + rb_yield(Data_Wrap_Struct(notmuch_rb_cMessage, NULL, NULL, message)); } return self; @@ -57,18 +68,14 @@ notmuch_rb_messages_each(VALUE self) VALUE notmuch_rb_messages_collect_tags(VALUE self) { - notmuch_rb_tags_t *tags; - notmuch_rb_messages_t *messages; - VALUE tagsv; + notmuch_tags_t *tags; + notmuch_messages_t *messages; - Data_Get_Struct(self, notmuch_rb_messages_t, messages); + Data_Get_Struct(self, notmuch_messages_t, messages); - tagsv = Data_Make_Struct(notmuch_rb_cTags, notmuch_rb_tags_t, - notmuch_rb_tags_mark, notmuch_rb_tags_free, tags); - tags->nm_tags = notmuch_messages_collect_tags(messages->nm_messages); - tags->parent = self; - if (!tags->nm_tags) - rb_raise(notmuch_rb_eMemoryError, "out of memory"); + tags = notmuch_messages_collect_tags(messages); + if (!tags) + rb_raise(notmuch_rb_eMemoryError, "Out of memory"); - return tagsv; + return Data_Wrap_Struct(notmuch_rb_cTags, NULL, NULL, tags); } diff --git a/bindings/ruby/query.c b/bindings/ruby/query.c index 50edf170..5140c008 100644 --- a/bindings/ruby/query.c +++ b/bindings/ruby/query.c @@ -20,6 +20,23 @@ #include "defs.h" +/* + * call-seq: QUERY.destroy => nil + * + * Destroys the query, freeing all resources allocated for it. + */ +VALUE +notmuch_rb_query_destroy(VALUE self) +{ + notmuch_query_t *query; + + Data_Get_Struct(self, notmuch_query_t, query); + + notmuch_query_destroy(query); + + return Qnil; +} + /* * call-seq: QUERY.sort=(fixnum) => nil * @@ -28,14 +45,15 @@ VALUE notmuch_rb_query_set_sort(VALUE self, VALUE sortv) { - notmuch_rb_query_t *query; + notmuch_query_t *query; - Data_Get_Struct(self, notmuch_rb_query_t, query); + Data_Get_Struct(self, notmuch_query_t, query); if (!FIXNUM_P(sortv)) rb_raise(rb_eTypeError, "Not a fixnum"); - notmuch_query_set_sort(query->nm_query, FIX2UINT(sortv)); + notmuch_query_set_sort(query, FIX2UINT(sortv)); + return Qnil; } @@ -47,20 +65,16 @@ notmuch_rb_query_set_sort(VALUE self, VALUE sortv) VALUE notmuch_rb_query_search_threads(VALUE self) { - notmuch_rb_query_t *query; - notmuch_rb_threads_t *threads; - VALUE threadsv; + notmuch_query_t *query; + notmuch_threads_t *threads; - Data_Get_Struct(self, notmuch_rb_query_t, query); + Data_Get_Struct(self, notmuch_query_t, query); - threadsv = Data_Make_Struct(notmuch_rb_cThreads, notmuch_rb_threads_t, - notmuch_rb_threads_mark, notmuch_rb_threads_free, threads); - threads->nm_threads = notmuch_query_search_threads(query->nm_query); - threads->query = self; - if (!threads->nm_threads) - rb_raise(notmuch_rb_eMemoryError, "out of memory"); + threads = notmuch_query_search_threads(query); + if (!threads) + rb_raise(notmuch_rb_eMemoryError, "Out of memory"); - return threadsv; + return Data_Wrap_Struct(notmuch_rb_cThreads, NULL, NULL, threads); } /* @@ -71,18 +85,14 @@ notmuch_rb_query_search_threads(VALUE self) VALUE notmuch_rb_query_search_messages(VALUE self) { - notmuch_rb_query_t *query; - notmuch_rb_messages_t *messages; - VALUE messagesv; + notmuch_query_t *query; + notmuch_messages_t *messages; - Data_Get_Struct(self, notmuch_rb_query_t, query); + Data_Get_Struct(self, notmuch_query_t, query); - messagesv = Data_Make_Struct(notmuch_rb_cMessages, notmuch_rb_messages_t, - notmuch_rb_messages_mark, notmuch_rb_messages_free, messages); - messages->nm_messages = notmuch_query_search_messages(query->nm_query); - messages->parent = self; - if (!messages->nm_messages) - rb_raise(notmuch_rb_eMemoryError, "out of memory"); + messages = notmuch_query_search_messages(query); + if (!messages) + rb_raise(notmuch_rb_eMemoryError, "Out of memory"); - return messagesv; + return Data_Wrap_Struct(notmuch_rb_cMessages, NULL, NULL, messages); } diff --git a/bindings/ruby/tags.c b/bindings/ruby/tags.c index d0a5054a..7ca03b6f 100644 --- a/bindings/ruby/tags.c +++ b/bindings/ruby/tags.c @@ -20,6 +20,23 @@ #include "defs.h" +/* + * call-seq: tags.destroy => nil + * + * Destroys the tags, freeing all resources allocated for it. + */ +VALUE +notmuch_rb_tags_destroy(VALUE self) +{ + notmuch_tags_t *tags; + + Data_Get_Struct(self, notmuch_tags_t, tags); + + notmuch_tags_destroy(tags); + + return Qnil; +} + /* * call-seq: TAGS.each {|item| block } => TAGS * @@ -30,16 +47,15 @@ VALUE notmuch_rb_tags_each(VALUE self) { const char *tag; - notmuch_rb_tags_t *tags; + notmuch_tags_t *tags; - Data_Get_Struct(self, notmuch_rb_tags_t, tags); - if (!tags->nm_tags) + Data_Get_Struct(self, notmuch_tags_t, tags); + if (!tags) return self; - for (; notmuch_tags_valid(tags->nm_tags); - notmuch_tags_move_to_next(tags->nm_tags)) { - tag = notmuch_tags_get(tags->nm_tags); - rb_yield(tag ? rb_str_new2(tag) : Qnil); + for (; notmuch_tags_valid(tags); notmuch_tags_move_to_next(tags)) { + tag = notmuch_tags_get(tags); + rb_yield(rb_str_new2(tag)); } return self; diff --git a/bindings/ruby/thread.c b/bindings/ruby/thread.c index 72a86b8f..5534fe3f 100644 --- a/bindings/ruby/thread.c +++ b/bindings/ruby/thread.c @@ -20,6 +20,23 @@ #include "defs.h" +/* + * call-seq: THREAD.destroy => nil + * + * Destroys the thread, freeing all resources allocated for it. + */ +VALUE +notmuch_rb_thread_destroy(VALUE self) +{ + notmuch_thread_t *thread; + + Data_Get_Struct(self, notmuch_thread_t, thread); + + notmuch_thread_destroy(thread); + + return Qnil; +} + /* * call-seq: THREAD.thread_id => String * @@ -29,12 +46,13 @@ VALUE notmuch_rb_thread_get_thread_id(VALUE self) { const char *tid; - notmuch_rb_thread_t *thread; + notmuch_thread_t *thread; - Data_Get_Struct(self, notmuch_rb_thread_t, thread); + Data_Get_Struct(self, notmuch_thread_t, thread); - tid = notmuch_thread_get_thread_id(thread->nm_thread); - return tid ? rb_str_new2(tid) : Qnil; + tid = notmuch_thread_get_thread_id(thread); + + return rb_str_new2(tid); } /* @@ -45,11 +63,11 @@ notmuch_rb_thread_get_thread_id(VALUE self) VALUE notmuch_rb_thread_get_total_messages(VALUE self) { - notmuch_rb_thread_t *thread; + notmuch_thread_t *thread; - Data_Get_Struct(self, notmuch_rb_thread_t, thread); + Data_Get_Struct(self, notmuch_thread_t, thread); - return INT2FIX(notmuch_thread_get_total_messages(thread->nm_thread)); + return INT2FIX(notmuch_thread_get_total_messages(thread)); } /* @@ -60,20 +78,16 @@ notmuch_rb_thread_get_total_messages(VALUE self) VALUE notmuch_rb_thread_get_toplevel_messages(VALUE self) { - notmuch_rb_messages_t *messages; - notmuch_rb_thread_t *thread; - VALUE messagesv; + notmuch_messages_t *messages; + notmuch_thread_t *thread; - Data_Get_Struct(self, notmuch_rb_thread_t, thread); + Data_Get_Struct(self, notmuch_thread_t, thread); - messagesv = Data_Make_Struct(notmuch_rb_cMessages, notmuch_rb_messages_t, - notmuch_rb_messages_mark, notmuch_rb_messages_free, messages); - messages->nm_messages = notmuch_thread_get_toplevel_messages(thread->nm_thread); - messages->parent = self; - if (!messages->nm_messages) - rb_raise(notmuch_rb_eMemoryError, "out of memory"); + messages = notmuch_thread_get_toplevel_messages(thread); + if (!messages) + rb_raise(notmuch_rb_eMemoryError, "Out of memory"); - return messagesv; + return Data_Wrap_Struct(notmuch_rb_cMessages, NULL, NULL, messages); } /* @@ -84,11 +98,11 @@ notmuch_rb_thread_get_toplevel_messages(VALUE self) VALUE notmuch_rb_thread_get_matched_messages(VALUE self) { - notmuch_rb_thread_t *thread; + notmuch_thread_t *thread; - Data_Get_Struct(self, notmuch_rb_thread_t, thread); + Data_Get_Struct(self, notmuch_thread_t, thread); - return INT2FIX(notmuch_thread_get_matched_messages(thread->nm_thread)); + return INT2FIX(notmuch_thread_get_matched_messages(thread)); } /* @@ -100,12 +114,13 @@ VALUE notmuch_rb_thread_get_authors(VALUE self) { const char *authors; - notmuch_rb_thread_t *thread; + notmuch_thread_t *thread; + + Data_Get_Struct(self, notmuch_thread_t, thread); - Data_Get_Struct(self, notmuch_rb_thread_t, thread); + authors = notmuch_thread_get_authors(thread); - authors = notmuch_thread_get_authors(thread->nm_thread); - return authors ? rb_str_new2(authors) : Qnil; + return rb_str_new2(authors); } /* @@ -117,12 +132,13 @@ VALUE notmuch_rb_thread_get_subject(VALUE self) { const char *subject; - notmuch_rb_thread_t *thread; + notmuch_thread_t *thread; + + Data_Get_Struct(self, notmuch_thread_t, thread); - Data_Get_Struct(self, notmuch_rb_thread_t, thread); + subject = notmuch_thread_get_subject(thread); - subject = notmuch_thread_get_subject(thread->nm_thread); - return subject ? rb_str_new2(subject) : Qnil; + return rb_str_new2(subject); } /* @@ -133,11 +149,11 @@ notmuch_rb_thread_get_subject(VALUE self) VALUE notmuch_rb_thread_get_oldest_date(VALUE self) { - notmuch_rb_thread_t *thread; + notmuch_thread_t *thread; - Data_Get_Struct(self, notmuch_rb_thread_t, thread); + Data_Get_Struct(self, notmuch_thread_t, thread); - return UINT2NUM(notmuch_thread_get_oldest_date(thread->nm_thread)); + return UINT2NUM(notmuch_thread_get_oldest_date(thread)); } /* @@ -148,11 +164,11 @@ notmuch_rb_thread_get_oldest_date(VALUE self) VALUE notmuch_rb_thread_get_newest_date(VALUE self) { - notmuch_rb_thread_t *thread; + notmuch_thread_t *thread; - Data_Get_Struct(self, notmuch_rb_thread_t, thread); + Data_Get_Struct(self, notmuch_thread_t, thread); - return UINT2NUM(notmuch_thread_get_newest_date(thread->nm_thread)); + return UINT2NUM(notmuch_thread_get_newest_date(thread)); } /* @@ -163,18 +179,14 @@ notmuch_rb_thread_get_newest_date(VALUE self) VALUE notmuch_rb_thread_get_tags(VALUE self) { - notmuch_rb_thread_t *thread; - notmuch_rb_tags_t *tags; - VALUE tagsv; + notmuch_thread_t *thread; + notmuch_tags_t *tags; - Data_Get_Struct(self, notmuch_rb_thread_t, thread); + Data_Get_Struct(self, notmuch_thread_t, thread); - tagsv = Data_Make_Struct(notmuch_rb_cTags, notmuch_rb_tags_t, - notmuch_rb_tags_mark, notmuch_rb_tags_free, tags); - tags->nm_tags = notmuch_thread_get_tags(thread->nm_thread); - tags->parent = self; - if (!tags->nm_tags) - rb_raise(notmuch_rb_eMemoryError, "out of memory"); + tags = notmuch_thread_get_tags(thread); + if (!tags) + rb_raise(notmuch_rb_eMemoryError, "Out of memory"); - return tagsv; + return Data_Wrap_Struct(notmuch_rb_cTags, NULL, NULL, tags); } diff --git a/bindings/ruby/threads.c b/bindings/ruby/threads.c index cee6afbe..09906975 100644 --- a/bindings/ruby/threads.c +++ b/bindings/ruby/threads.c @@ -20,6 +20,24 @@ #include "defs.h" +/* + * call-seq: THREADS.destroy => nil + * + * Destroys the threads, freeing all resources allocated for it. + */ +VALUE +notmuch_rb_threads_destroy(VALUE self) +{ + notmuch_threads_t *threads; + + Data_Get_Struct(self, notmuch_threads_t, threads); + + notmuch_threads_destroy(threads); + + return Qnil; +} + + /* call-seq: THREADS.each {|item| block } => THREADS * * Calls +block+ once for each thread in +self+, passing that element as a @@ -28,22 +46,16 @@ VALUE notmuch_rb_threads_each(VALUE self) { - notmuch_rb_thread_t *thread; - notmuch_rb_threads_t *threads; - VALUE threadv; + notmuch_thread_t *thread; + notmuch_threads_t *threads; - Data_Get_Struct(self, notmuch_rb_threads_t, threads); - if (!threads->nm_threads) + Data_Get_Struct(self, notmuch_threads_t, threads); + if (!threads) return self; - for (; notmuch_threads_valid(threads->nm_threads); - notmuch_threads_move_to_next(threads->nm_threads)) - { - threadv = Data_Make_Struct(notmuch_rb_cThread, notmuch_rb_thread_t, - notmuch_rb_thread_mark, notmuch_rb_thread_free, thread); - thread->nm_thread = notmuch_threads_get(threads->nm_threads); - thread->threads = self; - rb_yield(threadv); + for (; notmuch_threads_valid(threads); notmuch_threads_move_to_next(threads)) { + thread = notmuch_threads_get(threads); + rb_yield(Data_Wrap_Struct(notmuch_rb_cThread, NULL, NULL, thread)); } return self; -- 2.43.0