diff --git a/Makefile b/Makefile index 747408a6..b4d77b4e 100644 --- a/Makefile +++ b/Makefile @@ -18,6 +18,7 @@ MODULES= \ message-file.o \ query.o \ sha1.o \ + tags.o \ thread.o \ libsha1.o \ xutil.o diff --git a/message.cc b/message.cc index 5922cfcc..f3e39b4b 100644 --- a/message.cc +++ b/message.cc @@ -18,7 +18,7 @@ * Author: Carl Worth */ -#include "notmuch-private.h" +#include "notmuch-private-cxx.h" #include "database-private.h" #include @@ -32,15 +32,6 @@ struct _notmuch_message { Xapian::Document doc; }; -typedef struct _notmuch_terms { - char prefix_char; - Xapian::TermIterator iterator; - Xapian::TermIterator iterator_end; -} notmuch_terms_t; - -struct _notmuch_tags { - notmuch_terms_t terms; -}; /* "128 bits of thread-id ought to be enough for anybody" */ #define NOTMUCH_THREAD_ID_BITS 128 @@ -295,59 +286,6 @@ notmuch_message_get_filename (notmuch_message_t *message) return message->filename; } -/* We end up having to call the destructors explicitly because we had - * to use "placement new" in order to initialize C++ objects within a - * block that we allocated with talloc. So C++ is making talloc - * slightly less simple to use, (we wouldn't need - * talloc_set_destructor at all otherwise). - */ -static int -_notmuch_terms_destructor (notmuch_terms_t *terms) -{ - terms->iterator.~TermIterator (); - terms->iterator_end.~TermIterator (); - - return 0; -} - -static notmuch_terms_t * -_notmuch_terms_create (void *ctx, - Xapian::Document doc, - const char *prefix_name) -{ - notmuch_terms_t *terms; - const char *prefix = _find_prefix (prefix_name); - - /* Currently, notmuch_terms_t is written with the assumption that - * any prefix its derivatives use will be only a single - * character. */ - assert (strlen (prefix) == 1); - - terms = talloc (ctx, notmuch_terms_t); - if (unlikely (terms == NULL)) - return NULL; - - terms->prefix_char = *prefix; - new (&terms->iterator) Xapian::TermIterator; - new (&terms->iterator_end) Xapian::TermIterator; - - talloc_set_destructor (terms, _notmuch_terms_destructor); - - terms->iterator = doc.termlist_begin (); - terms->iterator.skip_to (prefix); - terms->iterator_end = doc.termlist_end (); - - return terms; -} - -/* The assertion is to ensure that 'type' is a derivative of - * notmuch_terms_t in that it contains a notmuch_terms_t as its first - * member. We do this by name of 'terms' as opposed to type, because - * that's as clever as I've been so far. */ -#define _notmuch_terms_create_type(ctx, doc, prefix_name, type) \ - (COMPILE_TIME_ASSERT(offsetof(type, terms) == 0), \ - (type *) _notmuch_terms_create (ctx, doc, prefix_name)) - notmuch_tags_t * notmuch_message_get_tags (notmuch_message_t *message) { @@ -525,60 +463,3 @@ notmuch_message_destroy (notmuch_message_t *message) { talloc_free (message); } - -static notmuch_bool_t -_notmuch_terms_has_more (notmuch_terms_t *terms) -{ - std::string s; - - if (terms->iterator == terms->iterator_end) - return FALSE; - - s = *terms->iterator; - if (! s.empty () && s[0] == terms->prefix_char) - return TRUE; - else - return FALSE; -} - -static const char * -_notmuch_terms_get (notmuch_terms_t *terms) -{ - return talloc_strdup (terms, (*terms->iterator).c_str () + 1); -} - -static void -_notmuch_terms_advance (notmuch_terms_t *terms) -{ - terms->iterator++; -} - -static void -_notmuch_terms_destroy (notmuch_terms_t *terms) -{ - talloc_free (terms); -} - -notmuch_bool_t -notmuch_tags_has_more (notmuch_tags_t *tags) -{ - return _notmuch_terms_has_more (&tags->terms); -} - -const char * -notmuch_tags_get (notmuch_tags_t *tags) -{ - return _notmuch_terms_get (&tags->terms); -} - -void -notmuch_tags_advance (notmuch_tags_t *tags) -{ - return _notmuch_terms_advance (&tags->terms); -} - -void -notmuch_tags_destroy (notmuch_tags_t *tags) -{ - return _notmuch_terms_destroy (&tags->terms); -} diff --git a/notmuch-private-cxx.h b/notmuch-private-cxx.h new file mode 100644 index 00000000..e177bf1f --- /dev/null +++ b/notmuch-private-cxx.h @@ -0,0 +1,60 @@ +/* notmuch-private-cxx.h - Internal, C++ interfaces for notmuch. + * + * Copyright © 2009 Carl Worth + * + * 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: Carl Worth + */ + +#ifndef NOTMUCH_PRIVATE_CXX_H +#define NOTMUCH_PRIVATE_CXX_H + +/* It's a bit annoying to have a separate C++ private header, but I + * don't yet have C wrappers for types like Xapian::Document and + * Xapian::PostingIterator. Maybe I'll write those to be able to fold + * this stuff back into notmuch-private.h */ + +#include "notmuch-private.h" + +#include + +/***********/ +/* tags.cc */ +/***********/ + +typedef struct _notmuch_terms { + char prefix_char; + Xapian::TermIterator iterator; + Xapian::TermIterator iterator_end; +} notmuch_terms_t; + +struct _notmuch_tags { + notmuch_terms_t terms; +}; + +notmuch_terms_t * +_notmuch_terms_create (void *ctx, + Xapian::Document doc, + const char *prefix_name); + +/* The assertion is to ensure that 'type' is a derivative of + * notmuch_terms_t in that it contains a notmuch_terms_t as its first + * member. We do this by name of 'terms' as opposed to type, because + * that's as clever as I've been so far. */ +#define _notmuch_terms_create_type(ctx, doc, prefix_name, type) \ + (COMPILE_TIME_ASSERT(offsetof(type, terms) == 0), \ + (type *) _notmuch_terms_create (ctx, doc, prefix_name)) + +#endif diff --git a/tags.cc b/tags.cc new file mode 100644 index 00000000..4fc06c06 --- /dev/null +++ b/tags.cc @@ -0,0 +1,126 @@ +/* tags.cc - Iterator for tags returned from message or thread + * + * Copyright © 2009 Carl Worth + * + * 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: Carl Worth + */ + +#include "notmuch-private-cxx.h" +#include "database-private.h" + +#include + +/* We end up having to call the destructors explicitly because we had + * to use "placement new" in order to initialize C++ objects within a + * block that we allocated with talloc. So C++ is making talloc + * slightly less simple to use, (we wouldn't need + * talloc_set_destructor at all otherwise). + */ +static int +_notmuch_terms_destructor (notmuch_terms_t *terms) +{ + terms->iterator.~TermIterator (); + terms->iterator_end.~TermIterator (); + + return 0; +} + +notmuch_terms_t * +_notmuch_terms_create (void *ctx, + Xapian::Document doc, + const char *prefix_name) +{ + notmuch_terms_t *terms; + const char *prefix = _find_prefix (prefix_name); + + /* Currently, notmuch_terms_t is written with the assumption that + * any prefix its derivatives use will be only a single + * character. */ + assert (strlen (prefix) == 1); + + terms = talloc (ctx, notmuch_terms_t); + if (unlikely (terms == NULL)) + return NULL; + + terms->prefix_char = *prefix; + new (&terms->iterator) Xapian::TermIterator; + new (&terms->iterator_end) Xapian::TermIterator; + + talloc_set_destructor (terms, _notmuch_terms_destructor); + + terms->iterator = doc.termlist_begin (); + terms->iterator.skip_to (prefix); + terms->iterator_end = doc.termlist_end (); + + return terms; +} + +static notmuch_bool_t +_notmuch_terms_has_more (notmuch_terms_t *terms) +{ + std::string s; + + if (terms->iterator == terms->iterator_end) + return FALSE; + + s = *terms->iterator; + if (! s.empty () && s[0] == terms->prefix_char) + return TRUE; + else + return FALSE; +} + +static const char * +_notmuch_terms_get (notmuch_terms_t *terms) +{ + return talloc_strdup (terms, (*terms->iterator).c_str () + 1); +} + +static void +_notmuch_terms_advance (notmuch_terms_t *terms) +{ + terms->iterator++; +} + +static void +_notmuch_terms_destroy (notmuch_terms_t *terms) +{ + talloc_free (terms); +} + +notmuch_bool_t +notmuch_tags_has_more (notmuch_tags_t *tags) +{ + return _notmuch_terms_has_more (&tags->terms); +} + +const char * +notmuch_tags_get (notmuch_tags_t *tags) +{ + return _notmuch_terms_get (&tags->terms); +} + +void +notmuch_tags_advance (notmuch_tags_t *tags) +{ + return _notmuch_terms_advance (&tags->terms); +} + +void +notmuch_tags_destroy (notmuch_tags_t *tags) +{ + return _notmuch_terms_destroy (&tags->terms); +}