mhs-xapian 1.0.18a

data/csharp/docs/examples/SimpleIndex.cs

@@ -0,0 +1,71 @@
+// Index each paragraph of a text file as a Xapian document.
+//
+// Copyright (c) 2003 James Aylett
+// Copyright (c) 2004,2006,2007 Olly Betts
+//
+// 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
+
+using System;
+
+class SimpleIndex {
+    public static void Main(string[] argv) {
+	if (argv.Length != 1) {
+	    Console.Error.WriteLine("Usage: SimpleIndex PATH_TO_DATABASE");
+	    Environment.Exit(1);
+	}
+
+	try {
+	    // Open the database for update, creating a new database if
+	    // necessary.
+	    Xapian.WritableDatabase database;
+	    database = new Xapian.WritableDatabase(argv[0], Xapian.Xapian.DB_CREATE_OR_OPEN);
+
+	    Xapian.TermGenerator indexer = new Xapian.TermGenerator();
+	    Xapian.Stem stemmer = new Xapian.Stem("english");
+	    indexer.SetStemmer(stemmer);
+
+	    string para = "";
+	    while (true) {
+		string line = Console.In.ReadLine();
+		if (line == null) {
+		    if (para == "") break;
+		    line = "";
+		}
+		line = line.Trim();
+		if (line == "") {
+		    if (para != "") {
+			// We've reached the end of a paragraph, so index it.
+			Xapian.Document doc = new Xapian.Document();
+			doc.SetData(para);
+
+			indexer.SetDocument(doc);
+			indexer.IndexText(para);
+
+			// Add the document to the database.
+			database.AddDocument(doc);
+			para = "";
+		    }
+		} else {
+		    if (para != "") para += " ";
+		    para += line;
+		}
+	    }
+	} catch (Exception e) {
+	    Console.Error.WriteLine("Exception: " + e.ToString());
+	    Environment.Exit(1);
+	}
+    }
+}

data/csharp/docs/examples/SimpleSearch.cs

@@ -0,0 +1,78 @@
+// Simple command-line search utility.
+//
+// Copyright (c) 2003 James Aylett
+// Copyright (c) 2004,2006,2007 Olly Betts
+//
+// 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
+
+using System;
+
+class SimpleIndex {
+    public static void Main(string[] argv) {
+	// We require at least two command line arguments.
+	if (argv.Length < 2) {
+	    Console.Error.WriteLine("Usage: SimpleSearch PATH_TO_DATABASE QUERY");
+	    Environment.Exit(1);
+	}
+
+	try {
+	    // Open the database for searching.
+	    Xapian.Database database = new Xapian.Database(argv[0]);
+
+	    // Start an enquire session.
+	    Xapian.Enquire enquire = new Xapian.Enquire(database);
+
+	    // Combine the rest of the command line arguments with spaces
+	    // between them, so that simple queries don't have to be quoted at
+	    // the shell level.
+	    string query_string = argv[1];
+	    for (int i = 2; i < argv.Length; ++i) {
+		query_string += ' ';
+		query_string += argv[i];
+	    }
+
+	    // Parse the query string to produce a Xapian::Query object.
+	    Xapian.QueryParser qp = new Xapian.QueryParser();
+	    Xapian.Stem stemmer = new Xapian.Stem("english");
+	    qp.SetStemmer(stemmer);
+	    qp.SetDatabase(database);
+	    qp.SetStemmingStrategy(Xapian.QueryParser.stem_strategy.STEM_SOME);
+	    Xapian.Query query = qp.ParseQuery(query_string);
+	    Console.WriteLine("Parsed query is: " + query.GetDescription());
+
+	    // Find the top 10 results for the query.
+	    enquire.SetQuery(query);
+	    Xapian.MSet matches = enquire.GetMSet(0, 10);
+
+	    // Display the results.
+	    Console.WriteLine("{0} results found.", matches.GetMatchesEstimated());
+	    Console.WriteLine("Matches 1-{0}:", matches.Size());
+
+	    Xapian.MSetIterator m = matches.Begin();
+	    while (m != matches.End()) {
+		Console.WriteLine("{0}: {1}% docid={2} [{3}]\n",
+				  m.GetRank() + 1,
+				  m.GetPercent(),
+				  m.GetDocId(),
+				  m.GetDocument().GetData());
+		++m;
+	    }
+	} catch (Exception e) {
+	    Console.Error.WriteLine("Exception: " + e.ToString());
+	    Environment.Exit(1);
+	}
+    }
+}

data/csharp/docs/index.html

@@ -0,0 +1,211 @@
+<html><head><title>C# bindings for Xapian</title></head>
+<body>
+<h1>C# bindings for Xapian</h1>
+
+<p>
+The C# bindings for Xapian are packaged in the <code>Xapian</code> namespace
+and largely follow the C++ API, with the following differences and
+additions.  C# strings and other types are converted automatically
+in the bindings, so generally it should just work as expected.
+</p>
+
+<p>
+The <code>examples</code> subdirectory contains examples showing how to use the
+C# bindings based on the simple examples from <code>xapian-examples</code>:
+<a href="examples/SimpleIndex.cs">SimpleIndex.cs</a>,
+<a href="examples/SimpleSearch.cs">SimpleSearch.cs</a>,
+<a href="examples/SimpleExpand.cs">SimpleExpand.cs</a>.
+</p>
+
+<p>
+Note: the passing of strings from C# into Xapian and back isn't currently
+zero byte safe.  If you try to handle string containing zero bytes, you'll
+find they get truncated at the zero byte.
+</p>
+
+<h2>Unicode Support</h2>
+
+<p>
+In Xapian 1.0.0 and later, the Xapian::Stem, Xapian::QueryParser, and
+Xapian::TermGenerator classes all assume text is in UTF-8.  If you're
+using Mono on UNIX with a UTF-8 locale (which is the default on most
+modern Linux distributions), then Xapian appears to get passed Unicode
+strings as UTF-8, so it should just work.  We tested with Mono 1.2.3.1
+using the Mono C# 2.0 compiler (gmcs).
+</p>
+
+<p>
+However, Microsoft and Mono's C# implementations apparently take
+rather different approaches to Unicode, and we've not tested with
+Microsoft's implementation.  If you try it, please report how well
+it works (or how badly it fails...)
+</p>
+
+<h2>Method Naming Conventions</h2>
+
+<p>
+   Methods are renamed to use the "CamelCase" capitalisation convention which C#
+   normally uses.  So in C# you use <code>GetDescription</code> instead of
+   <code>get_description</code>.
+</p>
+
+<h2>Exceptions</h2>
+
+<p>
+   Exceptions are thrown as SWIG exceptions instead of Xapian
+   exceptions. This isn't done well at the moment; in future we will
+   throw wrapped Xapian exceptions. For now, it's probably easier to
+   catch all exceptions and try to take appropriate action based on
+   their associated string.
+</p>
+
+<h2>Iterators</h2>
+
+<p>
+   The C#-wrapped iterators work much like their C++ counterparts, with
+   operators "++", "--", "==", and "!=" overloaded.  E.g.:
+</p>
+
+<pre>
+   Xapian.MSetIterator m = mset.begin();
+   while (m != mset.end()) {
+     // do something
+     ++m;
+   }
+</pre>
+
+<h2>Iterator dereferencing</h2>
+
+<p>
+   C++ iterators are often dereferenced to get information, eg
+   <code>(*it)</code>.  In C# these are all mapped to named methods, as
+   follows:
+</p>
+
+<table title='Iterator deferencing methods'>
+<thead><td>Iterator</td><td>Dereferencing method</td></thead>
+<tr><td>PositionIterator</td>	<td><code>GetTermPos()</code></td></tr>
+<tr><td>PostingIterator</td>	<td><code>GetDocId()</code></td></tr>
+<tr><td>TermIterator</td>	<td><code>GetTerm()</code></td></tr>
+<tr><td>ValueIterator</td>	<td><code>GetValue()</code></td></tr>
+<tr><td>MSetIterator</td>	<td><code>GetDocId()</code></td></tr>
+<tr><td>ESetIterator</td>	<td><code>GetTerm()</code></td></tr>
+</table>
+
+<p>
+   Other methods, such as <code>MSetIterator.GetDocument()</code>, are
+   available unchanged.
+</p>
+   
+<h2>MSet</h2>
+
+<p>
+   MSet objects have some additional methods to simplify access (these
+   work using the C++ array dereferencing):
+</p>
+
+<table title='MSet additional methods'>
+<thead><td>Method name</td><td>Explanation</td></thead>
+<tr><td><code>GetHit(index)</code></td><td>returns MSetIterator at index</td></tr>
+<tr><td><code>GetDocumentPercentage(index)</code></td><td><code>ConvertToPercent(GetHit(index))</code></td></tr>
+<tr><td><code>GetDocument(index)</code></td><td><code>GetHit(index).GetDocument()</code></td></tr>
+<tr><td><code>GetDocumentId(index)</code></td><td><code>GetHit(index).GetDocId()</code></td></tr>
+</table>
+
+<h2>Non-Class Functions</h2>
+
+<p>The C++ API contains a few non-class functions (the Database factory
+functions, and some functions reporting version information), but C# doesn't
+allow functions which aren't in a class so these are wrapped as static
+member functions of abstract classes like so:
+<ul>
+<ul>
+<li> <code>Xapian::version_string()</code> is wrapped as <code>Xapian.Version.String()</code>
+<li> <code>Xapian::major_version()</code> is wrapped as <code>Xapian.Version.Major()</code>
+<li> <code>Xapian::minor_version()</code> is wrapped as <code>Xapian.Version.Minor()</code>
+<li> <code>Xapian::revision()</code> is wrapped as <code>Xapian.Version.Revision()</code>
+</ul>
+<ul>
+<li> <code>Xapian::Auto::open_stub()</code> is wrapped as <code>Xapian.Auto.OpenStub()</code>
+<li> <code>Xapian::Flint::open()</code> is wrapped as <code>Xapian.Flint.Open()</code>
+<li> <code>Xapian::InMemory::open()</code> is wrapped as <code>Xapian.InMemory.Open()</code>
+<li> <code>Xapian::Quartz::open()</code> is wrapped as <code>Xapian.Quartz.Open()</code>
+<li> <code>Xapian::Remote::open()</code> is wrapped as <code>Xapian.Remote.Open()</code> (both
+the TCP and "program" versions are wrapped - the SWIG wrapper checks the parameter list to
+decide which to call).
+<li> <code>Xapian::Remote::open_writable()</code> is wrapped as <code>Xapian.Remote.OpenWritable()</code> (both
+the TCP and "program" versions are wrapped - the SWIG wrapper checks the parameter list to
+decide which to call).
+</ul>
+</ul>
+
+<h2>Constants</h2>
+
+<p>
+   The <code>Xapian::DB_*</code> constants are currently wrapped in a Xapian
+   class within the Xapian namespace, so have a double Xapian prefix!
+   So <code>Xapian::DB_CREATE_OR_OPEN</code> is available as
+   <code>Xapian.Xapian.DB_CREATE_OR_OPEN</code>.
+   The <code>Query::OP_*</code> constants are wrapped a little oddly too:
+   <code>Query::OP_OR</code> is wrapped as <code>Xapian.Query.op.OP_OR</code>.
+   Similarly, <code>QueryParser::STEM_SOME</code> as
+   <code>Xapian.QueryParser.stem_strategy.STEM_SOME</code>.
+   The naming here needs sorting out...
+</p>
+
+<h2>Query</h2>
+
+<p>
+   In C++ there's a Xapian::Query constructor which takes a query operator and
+   start/end iterators specifying a number of terms or queries, plus an optional
+   parameter.
+   This isn't currently wrapped in C#.
+<!-- FIXME implement this wrapping! 
+ 
+   In C#, this is wrapped to accept any C# sequence (for
+   example a list or tuple) to give the terms/queries, and you can specify
+   a mixture of terms and queries if you wish.  For example:
+   -->
+</p>
+
+<!--
+<pre>
+   subq = xapian.Query(xapian.Query.OP_AND, "hello", "world")
+   q = xapian.Query(xapian.Query.OP_AND, [subq, "foo", xapian.Query("bar", 2)])
+</pre>
+-->
+
+<!-- FIXME: Need to define the custom output typemap to handle this if it
+actually seems useful...
+<h2>Enquire</h2>
+
+<p>
+   There is an additional method <code>GetMatchingTerms()</code> which takes
+   an MSetIterator and returns a list of terms in the current query which
+   match the document given by that iterator.  You may find this
+   more convenient than using the TermIterator directly.
+</p>
+-->
+
+<h2>MatchDecider</h2>
+
+<p>
+Custom MatchDeciders can be created in C#; simply subclass
+Xapian.MatchDecider, and define an
+Apply method that will do the work. The simplest example (which does nothing
+useful) would be as follows:
+</p>
+
+<pre>
+class MyMatchDecider : Xapian.MatchDecider {
+    public override bool Apply(Xapian.Document doc) {
+	return true;
+    }
+}
+</pre>
+
+<address>
+Last updated $Date: 2005-12-12T02:56:23.742308Z $
+</address>
+</body>
+</html>

data/csharp/util.i

@@ -0,0 +1,233 @@
+%{
+/* csharp/util.i: custom C# typemaps for xapian-bindings
+ *
+ * Copyright (c) 2005,2006 Olly Betts
+ *
+ * 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
+ */
+
+// In C#, we don't get SWIG_exception in the generated C++ wrapper sources.
+#define XapianException(TYPE, MSG) SWIG_CSharpException(TYPE, (MSG).c_str())
+%}
+
+// Use SWIG directors for C# wrappers.
+#define XAPIAN_SWIG_DIRECTORS
+
+// Rename function and method names to match C# conventions (e.g. from
+// get_description() to GetDescription()).
+%rename("%(camelcase)s",%$isfunction) "";
+
+// Fix up API methods which aren't split by '_' on word boundaries.
+%rename("GetTermPos") get_termpos;
+%rename("GetTermFreq") get_termfreq;
+%rename("GetTermWeight") get_termweight;
+%rename("GetTermName") get_termname;
+%rename("GetDocCount") get_doccount;
+%rename("GetDocId") get_docid;
+%rename("GetDocLength") get_doclength;
+%rename("GetDocumentId") get_document_id;
+%rename("PositionListBegin") positionlist_begin;
+%rename("PositionListEnd") positionlist_end;
+%rename("GetValueNo") get_valueno;
+%rename("TermListCount") termlist_count;
+%rename("TermListBegin") termlist_begin;
+%rename("TermListEnd") termlist_end;
+%rename("GetFirstItem") get_firstitem;
+%rename("GetSumPart") get_sumpart;
+%rename("GetMaxPart") get_maxpart;
+%rename("GetSumExtra") get_sumextra;
+%rename("GetMaxExtra") get_maxextra;
+%rename("GetSumPartNeedsDocLength") get_sumpart_needs_doclength;
+%rename("PostListBegin") postlist_begin;
+%rename("PostListEnd") postlist_end;
+%rename("AllTermsBegin") allterms_begin;
+%rename("AllTermsEnd") allterms_end;
+%rename("GetLastDocId") get_lastdocid;
+%rename("GetAvLength") get_avlength;
+%rename("StopListBegin") stoplist_begin;
+%rename("StopListEnd") stoplist_end;
+%rename("GetMSet") get_mset;
+%rename("GetESet") get_eset;
+
+%ignore ValueRangeProcessor::operator();
+
+%inline {
+namespace Xapian {
+
+// Wrap Xapian::version_string as Xapian.Version.String() as C# can't have
+// functions outside a class and we don't want Xapian.Xapian.VersionString()!
+class Version {
+  private:
+    Version();
+    ~Version();
+  public:
+    static const char * String() { return Xapian::version_string(); }
+    static int Major() { return Xapian::major_version(); }
+    static int Minor() { return Xapian::minor_version(); }
+    static int Revision() { return Xapian::revision(); }
+};
+
+}
+}
+
+namespace Xapian {
+
+%ignore version_string;
+%ignore major_version;
+%ignore minor_version;
+%ignore revision;
+
+%typemap(cscode) class MSetIterator %{
+    public static MSetIterator operator++(MSetIterator it) {
+	return it.Next();
+    }
+    public static MSetIterator operator--(MSetIterator it) {
+	return it.Prev();
+    }
+    public override bool Equals(object o) {
+	return o is MSetIterator && Equals((MSetIterator)o);
+    }
+    public static bool operator==(MSetIterator a, MSetIterator b) {
+	if ((object)a == (object)b) return true;
+	if ((object)a == null || (object)b == null) return false;
+	return a.Equals(b);
+    }
+    public static bool operator!=(MSetIterator a, MSetIterator b) {
+	if ((object)a == (object)b) return false;
+	if ((object)a == null || (object)b == null) return true;
+	return !a.Equals(b);
+    }
+    // Implementing GetHashCode() to always return 0 is rather lame, but
+    // using iterators as keys in a hash table would be rather strange.
+    public override int GetHashCode() { return 0; }
+%}
+
+%typemap(cscode) ESetIterator %{
+    public static ESetIterator operator++(ESetIterator it) {
+	return it.Next();
+    }
+    public static ESetIterator operator--(ESetIterator it) {
+	return it.Prev();
+    }
+    public override bool Equals(object o) {
+	return o is ESetIterator && Equals((ESetIterator)o);
+    }
+    public static bool operator==(ESetIterator a, ESetIterator b) {
+	if ((object)a == (object)b) return true;
+	if ((object)a == null || (object)b == null) return false;
+	return a.Equals(b);
+    }
+    public static bool operator!=(ESetIterator a, ESetIterator b) {
+	if ((object)a == (object)b) return false;
+	if ((object)a == null || (object)b == null) return true;
+	return !a.Equals(b);
+    }
+    // Implementing GetHashCode() to always return 0 is rather lame, but
+    // using iterators as keys in a hash table would be rather strange.
+    public override int GetHashCode() { return 0; }
+%}
+
+%typemap(cscode) TermIterator %{
+    public static TermIterator operator++(TermIterator it) {
+	return it.Next();
+    }
+    public override bool Equals(object o) {
+	return o is TermIterator && Equals((TermIterator)o);
+    }
+    public static bool operator==(TermIterator a, TermIterator b) {
+	if ((object)a == (object)b) return true;
+	if ((object)a == null || (object)b == null) return false;
+	return a.Equals(b);
+    }
+    public static bool operator!=(TermIterator a, TermIterator b) {
+	if ((object)a == (object)b) return false;
+	if ((object)a == null || (object)b == null) return true;
+	return !a.Equals(b);
+    }
+    // Implementing GetHashCode() to always return 0 is rather lame, but
+    // using iterators as keys in a hash table would be rather strange.
+    public override int GetHashCode() { return 0; }
+%}
+
+%typemap(cscode) ValueIterator %{
+    public static ValueIterator operator++(ValueIterator it) {
+	return it.Next();
+    }
+    public override bool Equals(object o) {
+	return o is ValueIterator && Equals((ValueIterator)o);
+    }
+    public static bool operator==(ValueIterator a, ValueIterator b) {
+	if ((object)a == (object)b) return true;
+	if ((object)a == null || (object)b == null) return false;
+	return a.Equals(b);
+    }
+    public static bool operator!=(ValueIterator a, ValueIterator b) {
+	if ((object)a == (object)b) return false;
+	if ((object)a == null || (object)b == null) return true;
+	return !a.Equals(b);
+    }
+    // Implementing GetHashCode() to always return 0 is rather lame, but
+    // using iterators as keys in a hash table would be rather strange.
+    public override int GetHashCode() { return 0; }
+%}
+
+%typemap(cscode) PostingIterator %{
+    public static PostingIterator operator++(PostingIterator it) {
+	return it.Next();
+    }
+    public override bool Equals(object o) {
+	return o is PostingIterator && Equals((PostingIterator)o);
+    }
+    public static bool operator==(PostingIterator a, PostingIterator b) {
+	if ((object)a == (object)b) return true;
+	if ((object)a == null || (object)b == null) return false;
+	return a.Equals(b);
+    }
+    public static bool operator!=(PostingIterator a, PostingIterator b) {
+	if ((object)a == (object)b) return false;
+	if ((object)a == null || (object)b == null) return true;
+	return !a.Equals(b);
+    }
+    // Implementing GetHashCode() to always return 0 is rather lame, but
+    // using iterators as keys in a hash table would be rather strange.
+    public override int GetHashCode() { return 0; }
+%}
+
+%typemap(cscode) PositionIterator %{
+    public static PositionIterator operator++(PositionIterator it) {
+	return it.Next();
+    }
+    public override bool Equals(object o) {
+	return o is PositionIterator && Equals((PositionIterator)o);
+    }
+    public static bool operator==(PositionIterator a, PositionIterator b) {
+	if ((object)a == (object)b) return true;
+	if ((object)a == null || (object)b == null) return false;
+	return a.Equals(b);
+    }
+    public static bool operator!=(PositionIterator a, PositionIterator b) {
+	if ((object)a == (object)b) return false;
+	if ((object)a == null || (object)b == null) return true;
+	return !a.Equals(b);
+    }
+    // Implementing GetHashCode() to always return 0 is rather lame, but
+    // using iterators as keys in a hash table would be rather strange.
+    public override int GetHashCode() { return 0; }
+%}
+
+}
+
+/* vim:set syntax=cpp:set noexpandtab: */