First commit.

1 files changed, 471 insertions, 0 deletions

diff --git a/xapian-headers.i b/xapian-headers.i
new file mode 100644
index 0000000..4b393a1
--- /dev/null
+++ b/xapian-headers.i
@@ -0,0 +1,471 @@
+%{
+/* xapian-headers.i: Getting SWIG to parse Xapian's C++ headers.
+ *
+ * Copyright 2004,2006,2011,2012,2013,2014,2015,2016,2019 Olly Betts
+ * Copyright 2014 Assem Chelli
+ *
+ * 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 2 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
+ * USA
+ */
+%}
+
+/* Ignore these functions: */
+%ignore Xapian::iterator_rewind;
+%ignore Xapian::iterator_valid;
+
+/* Ignore anything ending in an underscore, which is for internal use only: */
+%rename("$ignore", regexmatch$name="_$") "";
+
+/* A class which can usefully be subclassed in the target language. */
+%define SUBCLASSABLE(NS, CLASS)
+    %ignore NS::CLASS::clone;
+    %ignore NS::CLASS::serialise;
+    %ignore NS::CLASS::unserialise;
+    %#ifdef XAPIAN_SWIG_DIRECTORS
+    %feature(director) NS::CLASS;
+    %#endif
+%enddef
+
+/* A class which is only useful to wrap if the target language allows
+ * subclassing of wrapped classes (what SWIG calls "director support").
+ */
+#ifdef XAPIAN_SWIG_DIRECTORS
+#define SUBCLASSABLE_ONLY(NS, CLASS) SUBCLASSABLE(NS, CLASS)
+#else
+#define SUBCLASSABLE_ONLY(NS, CLASS) %ignore NS::CLASS;
+#endif
+
+#ifdef SWIGTCL
+/* Tcl needs copy constructors it seems. */
+%define STANDARD_IGNORES(NS, CLASS)
+    %ignore NS::CLASS::internal;
+    %ignore NS::CLASS::CLASS(Internal*);
+    %ignore NS::CLASS::CLASS(Internal&);
+    %ignore NS::CLASS::operator=;
+%enddef
+#else
+%define STANDARD_IGNORES(NS, CLASS)
+    %ignore NS::CLASS::internal;
+    %ignore NS::CLASS::CLASS(Internal*);
+    %ignore NS::CLASS::CLASS(Internal&);
+    %ignore NS::CLASS::operator=;
+    %ignore NS::CLASS::CLASS(const CLASS &);
+%enddef
+#endif
+
+#ifdef SWIGCSHARP
+/* In C#, next and prev return the iterator object. */
+#define INC_OR_DEC(METHOD, OP, NS, CLASS, RET_TYPE) NS::CLASS METHOD() { return OP(*self); }
+#elif defined SWIGJAVA
+/* In Java, next and prev return the result of dereferencing the iterator. */
+#define INC_OR_DEC(METHOD, OP, NS, CLASS, RET_TYPE) RET_TYPE METHOD() { return *(OP(*self)); }
+#else
+/* Otherwise, next and prev return void. */
+#define INC_OR_DEC(METHOD, OP, NS, CLASS, RET_TYPE) void METHOD() { OP(*self); }
+#endif
+
+/* For other languages, SWIG already renames operator() suitably. */
+#if defined SWIGGUILE || defined SWIGJAVA || defined SWIGPHP || defined SWIGTCL
+%rename(apply) *::operator();
+#elif defined SWIGCSHARP
+%rename(Apply) *::operator();
+#endif
+
+/* We use %ignore and %extend rather than %rename on operator* so that any
+ * pattern rename used to match local naming conventions applies to
+ * DEREF_METHOD.
+ */
+%define INPUT_ITERATOR_METHODS(NS, CLASS, RET_TYPE, DEREF_METHOD)
+    STANDARD_IGNORES(NS, CLASS)
+    %ignore NS::CLASS::operator++;
+    %ignore NS::CLASS::operator*;
+    %extend NS::CLASS {
+	bool equals(const NS::CLASS & o) const { return *self == o; }
+	RET_TYPE DEREF_METHOD() const { return **self; }
+	INC_OR_DEC(next, ++, NS, CLASS, RET_TYPE)
+    }
+%enddef
+
+%define RANDOM_ACCESS_ITERATOR_METHODS(NS, CLASS, RET_TYPE, DEREF_METHOD)
+    INPUT_ITERATOR_METHODS(NS, CLASS, RET_TYPE, DEREF_METHOD)
+    %ignore NS::CLASS::operator--;
+    %ignore NS::CLASS::operator+=;
+    %ignore NS::CLASS::operator-=;
+    %ignore NS::CLASS::operator+;
+    %ignore NS::CLASS::operator-;
+    %extend NS::CLASS {
+	INC_OR_DEC(prev, --, NS, CLASS, RET_TYPE)
+    }
+%enddef
+
+%define CONSTANT(TYPE, NS, NAME)
+    %ignore NS::NAME;
+    %constant TYPE NAME = NS::NAME;
+%enddef
+
+/* Ignore these for all classes: */
+%ignore operator==;
+%ignore operator!=;
+%ignore operator<;
+%ignore operator>;
+%ignore operator<=;
+%ignore operator>=;
+%ignore operator+;
+%ignore difference_type;
+%ignore iterator_category;
+%ignore value_type;
+%ignore max_size;
+%ignore swap;
+%ignore iterator;
+%ignore const_iterator;
+%ignore size_type;
+%ignore unserialise(const char **, const char *);
+%ignore release();
+
+/* These methods won't throw exceptions. */
+%exception Xapian::major_version "$action"
+%exception Xapian::minor_version "$action"
+%exception Xapian::revision "$action"
+%exception Xapian::version_string "$action"
+// For XAPIAN_DOCID_BASE_TYPE and XAPIAN_TERMCOUNT_BASE_TYPE:
+%import <xapian/version.h>
+%include <xapian.h>
+
+// Disable errors about not including headers individually.
+#define XAPIAN_IN_XAPIAN_H
+
+/* We don't wrap the version macros - they're useful for compile time checks
+ * in C++ code, but for a scripting language, the version functions tell us
+ * the version of Xapian we're actually using, which is more interesting than
+ * the one the bindings were built against.
+ */
+/* %include <xapian/version.h> */
+
+CONSTANT(Xapian::valueno, Xapian, BAD_VALUENO);
+
+/* Types are needed by most of the other headers. */
+%include <xapian/types.h>
+
+CONSTANT(int, Xapian, DB_CREATE);
+CONSTANT(int, Xapian, DB_CREATE_OR_OPEN);
+CONSTANT(int, Xapian, DB_CREATE_OR_OVERWRITE);
+CONSTANT(int, Xapian, DB_OPEN);
+CONSTANT(int, Xapian, DB_NO_SYNC);
+CONSTANT(int, Xapian, DB_FULL_SYNC);
+CONSTANT(int, Xapian, DB_DANGEROUS);
+CONSTANT(int, Xapian, DB_NO_TERMLIST);
+CONSTANT(int, Xapian, DB_BACKEND_CHERT);
+CONSTANT(int, Xapian, DB_BACKEND_GLASS);
+CONSTANT(int, Xapian, DB_BACKEND_INMEMORY);
+CONSTANT(int, Xapian, DB_BACKEND_STUB);
+CONSTANT(int, Xapian, DB_RETRY_LOCK);
+CONSTANT(int, Xapian, DBCHECK_SHORT_TREE);
+CONSTANT(int, Xapian, DBCHECK_FULL_TREE);
+CONSTANT(int, Xapian, DBCHECK_SHOW_FREELIST);
+CONSTANT(int, Xapian, DBCHECK_SHOW_STATS);
+CONSTANT(int, Xapian, DBCHECK_FIX);
+CONSTANT(int, Xapian, DBCOMPACT_MULTIPASS);
+CONSTANT(int, Xapian, DBCOMPACT_NO_RENUMBER);
+CONSTANT(int, Xapian, DBCOMPACT_SINGLE_FILE);
+CONSTANT(int, Xapian, DOC_ASSUME_VALID);
+%include <xapian/constants.h>
+
+/* The Error subclasses are handled separately for languages where we wrap
+ * them. */
+/* %include <xapian/error.h> */
+
+/* ErrorHandler isn't currently wrapped. */
+/* %include <xapian/errorhandler.h> */
+
+INPUT_ITERATOR_METHODS(Xapian, PositionIterator, Xapian::termpos, get_termpos)
+%include <xapian/positioniterator.h>
+
+%ignore Xapian::DocIDWrapper;
+INPUT_ITERATOR_METHODS(Xapian, PostingIterator, Xapian::docid, get_docid)
+%include <xapian/postingiterator.h>
+
+INPUT_ITERATOR_METHODS(Xapian, TermIterator, std::string, get_term)
+%include <xapian/termiterator.h>
+
+INPUT_ITERATOR_METHODS(Xapian, ValueIterator, std::string, get_value)
+%include <xapian/valueiterator.h>
+
+STANDARD_IGNORES(Xapian, Document)
+%include <xapian/document.h>
+
+STANDARD_IGNORES(Xapian, Registry)
+%include <xapian/registry.h>
+
+STANDARD_IGNORES(Xapian, Query)
+%ignore Xapian::Query::Internal;
+%ignore operator Query;
+%ignore *::operator&(const Xapian::Query &, const Xapian::InvertedQuery_ &);
+%ignore *::operator~;
+%ignore *::operator&=;
+%ignore ::operator&=;
+%ignore *::operator|=;
+%ignore *::operator^=;
+%ignore *::operator*=;
+%ignore *::operator/=;
+#if defined SWIGCSHARP || defined SWIGGUILE || defined SWIGJAVA || defined SWIGLUA || defined SWIGPHP
+%ignore *::operator&;
+%ignore *::operator|;
+%ignore *::operator^;
+%ignore *::operator*;
+%ignore *::operator/;
+#endif
+%ignore Xapian::Query::LEAF_TERM;
+%ignore Xapian::Query::LEAF_POSTING_SOURCE;
+%ignore Xapian::Query::LEAF_MATCH_ALL;
+%ignore Xapian::Query::LEAF_MATCH_NOTHING;
+
+%warnfilter(SWIGWARN_TYPE_UNDEFINED_CLASS) Xapian::Query::Internal;
+#if defined SWIGCSHARP || defined SWIGJAVA || defined SWIGPERL || \
+    defined SWIGPYTHON || defined SWIGRUBY
+// C#, Java, Perl, Python and Ruby wrap these "by hand" to give a nicer API
+// than SWIG gives by default.
+%ignore Xapian::Query::MatchAll;
+%ignore Xapian::Query::MatchNothing;
+#endif
+#ifndef XAPIAN_MIXED_SUBQUERIES_BY_ITERATOR_TYPEMAP
+%ignore Query(op op_, XapianSWIGQueryItor qbegin, XapianSWIGQueryItor qend,
+	      Xapian::termcount parameter = 0);
+#endif
+%include <xapian/query.h>
+
+// Suppress warning that Xapian::Internal::intrusive_base is unknown.
+%warnfilter(SWIGWARN_TYPE_UNDEFINED_CLASS) Xapian::StemImplementation;
+SUBCLASSABLE_ONLY(Xapian, StemImplementation)
+#ifndef XAPIAN_SWIG_DIRECTORS
+%ignore Xapian::Stem::Stem(Xapian::StemImplementation *);
+#endif
+STANDARD_IGNORES(Xapian, Stem)
+%ignore Xapian::Stem::Stem();
+%include <xapian/stem.h>
+
+STANDARD_IGNORES(Xapian, TermGenerator)
+%ignore Xapian::TermGenerator::operator=;
+/* Ignore forms which use Utf8Iterator, as we don't wrap that class. */
+%ignore Xapian::TermGenerator::index_text(const Xapian::Utf8Iterator &);
+%ignore Xapian::TermGenerator::index_text(const Xapian::Utf8Iterator &, Xapian::termcount);
+%ignore Xapian::TermGenerator::index_text(const Xapian::Utf8Iterator &, Xapian::termcount, const std::string &);
+%ignore Xapian::TermGenerator::index_text_without_positions(const Xapian::Utf8Iterator &);
+%ignore Xapian::TermGenerator::index_text_without_positions(const Xapian::Utf8Iterator &, Xapian::termcount);
+%ignore Xapian::TermGenerator::index_text_without_positions(const Xapian::Utf8Iterator &, Xapian::termcount, const std::string &);
+%ignore Xapian::TermGenerator::TermGenerator(const TermGenerator &);
+%include <xapian/termgenerator.h>
+
+STANDARD_IGNORES(Xapian, MSet)
+#ifdef SWIGJAVA
+// For compatibility with the original JNI wrappers.
+%rename("getElement") Xapian::MSet::operator[];
+#else
+%ignore Xapian::MSet::operator[];
+#endif
+%extend Xapian::MSet {
+    Xapian::docid get_docid(Xapian::doccount i) const {
+	return *(*self)[i];
+    }
+
+    Xapian::Document get_document(Xapian::doccount i) const {
+	return (*self)[i].get_document();
+    }
+
+    Xapian::MSetIterator get_hit(Xapian::doccount i) const {
+	return (*self)[i];
+    }
+
+    int get_document_percentage(Xapian::doccount i) const {
+	return self->convert_to_percent((*self)[i]);
+    }
+}
+
+RANDOM_ACCESS_ITERATOR_METHODS(Xapian, MSetIterator, Xapian::docid, get_docid)
+
+%include <xapian/mset.h>
+
+STANDARD_IGNORES(Xapian, ESet)
+%ignore Xapian::ESet::operator[];
+
+RANDOM_ACCESS_ITERATOR_METHODS(Xapian, ESetIterator, std::string, get_term)
+
+%include <xapian/eset.h>
+
+STANDARD_IGNORES(Xapian, RSet)
+
+STANDARD_IGNORES(Xapian, Enquire)
+
+SUBCLASSABLE(Xapian, MatchDecider)
+
+#ifdef XAPIAN_TERMITERATOR_PAIR_OUTPUT_TYPEMAP
+/* Instantiating the template we're going to use avoids SWIG wrapping uses
+ * of it in SwigValueWrapper.
+ */
+%template() std::pair<Xapian::TermIterator, Xapian::TermIterator>;
+
+%extend Xapian::Enquire {
+    /* This returns start and end iterators, then a typemap iterates between
+     * those and returns an array of strings in the target language.
+     */
+    std::pair<Xapian::TermIterator, Xapian::TermIterator>
+    get_matching_terms(const Xapian::MSetIterator & item) const {
+	return std::make_pair($self->get_matching_terms_begin(item),
+			      $self->get_matching_terms_end(item));
+    }
+}
+#endif
+
+/* We don't wrap ErrorHandler, so ignore the optional ErrorHandler parameter.
+ */
+%ignore Enquire(const Database &, ErrorHandler *);
+
+%include <xapian/enquire.h>
+
+SUBCLASSABLE(Xapian, ExpandDecider)
+// Suppress warning that Xapian::Internal::opt_intrusive_base is unknown.
+%warnfilter(SWIGWARN_TYPE_UNDEFINED_CLASS) Xapian::ExpandDecider;
+%ignore Xapian::ExpandDeciderAnd::ExpandDeciderAnd(const ExpandDecider *, const ExpandDecider *);
+/* FIXME: %extend ExpandDeciderFilterTerms so it can be constructed from an
+ * array of strings (or whatever the equivalent is in the target language).
+ */
+%ignore Xapian::ExpandDeciderFilterTerms;
+%include <xapian/expanddecider.h>
+
+SUBCLASSABLE(Xapian, KeyMaker)
+// Suppress warning that Xapian::Internal::opt_intrusive_base is unknown.
+%warnfilter(SWIGWARN_TYPE_UNDEFINED_CLASS) Xapian::KeyMaker;
+%include <xapian/keymaker.h>
+
+%extend Xapian::SimpleStopper {
+    /** Load stop words from a text file (one word per line). */
+    SimpleStopper(const std::string &file) {
+	ifstream in_file(file.c_str());
+	if (!in_file.is_open())
+	    throw Xapian::InvalidArgumentError("Stopword file not found: " + file);
+	istream_iterator<std::string> in_iter(in_file);
+	istream_iterator<std::string> eof;
+	return new Xapian::SimpleStopper(in_iter, eof);
+    }
+}
+
+SUBCLASSABLE(Xapian, FieldProcessor)
+// Suppress warning that Xapian::Internal::opt_intrusive_base is unknown.
+%warnfilter(SWIGWARN_TYPE_UNDEFINED_CLASS) Xapian::Stopper;
+SUBCLASSABLE(Xapian, RangeProcessor)
+SUBCLASSABLE(Xapian, Stopper)
+SUBCLASSABLE(Xapian, ValueRangeProcessor)
+// Suppress warning that Xapian::Internal::opt_intrusive_base is unknown.
+%warnfilter(SWIGWARN_TYPE_UNDEFINED_CLASS) Xapian::RangeProcessor;
+%warnfilter(SWIGWARN_TYPE_UNDEFINED_CLASS) Xapian::ValueRangeProcessor;
+%warnfilter(SWIGWARN_TYPE_UNDEFINED_CLASS) Xapian::FieldProcessor;
+STANDARD_IGNORES(Xapian, QueryParser)
+%ignore Xapian::QueryParser::QueryParser(const QueryParser &);
+CONSTANT(int, Xapian, RP_SUFFIX);
+CONSTANT(int, Xapian, RP_REPEATED);
+CONSTANT(int, Xapian, RP_DATE_PREFER_MDY);
+%include <xapian/queryparser.h>
+
+%include <xapian/valuesetmatchdecider.h>
+
+/* Xapian::Weight isn't usefully subclassable via the bindings, as clone()
+ * needs to be implemented for it to be usable for weighting a search.  But
+ * there are several supplied weighting schemes implemented in C++ which can
+ * usefully be used via the bindings so we wrap those.
+ */
+STANDARD_IGNORES(Xapian, Weight)
+/* The copy constructor isn't implemented, but is protected rather than
+ * private to work around a compiler bug, so we ignore it explicitly.
+ */
+%ignore Xapian::Weight::Weight(const Weight &);
+%ignore Xapian::Weight::clone;
+%ignore Xapian::Weight::serialise;
+%ignore Xapian::Weight::unserialise;
+%include <xapian/weight.h>
+
+/* We don't wrap Xapian's Unicode support as other languages usually already
+ * have their own Unicode support. */
+/* %include <xapian/unicode.h> */
+
+SUBCLASSABLE(Xapian, Compactor)
+%include <xapian/compactor.h>
+
+SUBCLASSABLE(Xapian, PostingSource)
+// Suppress warning that Xapian::Internal::opt_intrusive_base is unknown.
+%warnfilter(SWIGWARN_TYPE_UNDEFINED_CLASS) Xapian::PostingSource;
+SUBCLASSABLE(Xapian, ValuePostingSource)
+SUBCLASSABLE(Xapian, ValueWeightPostingSource)
+%ignore Xapian::PostingSource::unserialise_with_registry;
+%include <xapian/postingsource.h>
+
+// Suppress warning that Xapian::Internal::intrusive_base is unknown.
+%warnfilter(SWIGWARN_TYPE_UNDEFINED_CLASS) Xapian::MatchSpy;
+SUBCLASSABLE(Xapian, MatchSpy)
+%ignore Xapian::MatchSpy::serialise_results;
+%include <xapian/matchspy.h>
+
+SUBCLASSABLE(Xapian, LatLongMetric)
+INPUT_ITERATOR_METHODS(Xapian, LatLongCoordsIterator, LatLongCoord, get_coord)
+%ignore Xapian::LatLongCoord::operator<;
+%include <xapian/geospatial.h>
+
+STANDARD_IGNORES(Xapian, Database)
+STANDARD_IGNORES(Xapian, WritableDatabase)
+%ignore Xapian::WritableDatabase::WritableDatabase(Database::Internal *);
+%ignore Xapian::Database::check(const std::string &, int, std::ostream *);
+%ignore Xapian::Database::check(int fd, int, std::ostream *);
+%include <xapian/database.h>
+%extend Xapian::Database {
+    static size_t check(const std::string &path, int opts = 0) {
+	return Xapian::Database::check(path, opts, opts ? &std::cout : NULL);
+    }
+}
+
+#if defined SWIGCSHARP || defined SWIGJAVA
+
+/* xapian/dbfactory.h is currently wrapped via fake class declarations in
+ * fake_dbfactory.i for C# and Java. */
+
+#else
+
+#ifdef XAPIAN_BINDINGS_SKIP_DEPRECATED_DB_FACTORIES
+%ignore Xapian::InMemory::open;
+%ignore Xapian::Chert::open;
+%ignore Xapian::Auto::open_stub;
+#else
+
+%rename("inmemory_open") Xapian::InMemory::open;
+
+/* SWIG Tcl wrappers don't call destructors for classes returned by factory
+ * functions, so we don't wrap them so users are forced to use the
+ * WritableDatabase ctor instead. */
+#ifdef SWIGTCL
+%ignore Xapian::Chert::open(const std::string &dir, int action, int block_size = 8192);
+#endif
+
+%rename("chert_open") Xapian::Chert::open;
+
+#ifndef SWIGPHP
+/* PHP renames this to auto_open_stub() in php/php.i. */
+%rename("open_stub") Xapian::Auto::open_stub;
+#endif
+
+#endif
+
+%rename("remote_open") Xapian::Remote::open;
+%rename("remote_open_writable") Xapian::Remote::open_writable;
+
+%include <xapian/dbfactory.h>
+
+#endif