You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucy.apache.org by nw...@apache.org on 2014/11/23 18:42:58 UTC
svn commit: r1641230 [4/5] - /lucy/site/trunk/content/docs/c/
Added: lucy/site/trunk/content/docs/c/lucy_Query.html
URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/lucy_Query.html?rev=1641230&view=auto
==============================================================================
--- lucy/site/trunk/content/docs/c/lucy_Query.html (added)
+++ lucy/site/trunk/content/docs/c/lucy_Query.html Sun Nov 23 17:42:57 2014
@@ -0,0 +1,153 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta name="viewport" content="width=device-width" />
+<style type="text/css">
+body {
+ font-family: sans-serif;
+ font-size: 0.85em;
+ max-width: 640px;
+}
+dt {
+ font-weight: bold;
+}
+pre {
+ border: 1px solid #000;
+ padding: 0.2em 0.4em;
+ background: #f6f6f6;
+ font-size: 1.2em;
+}
+code {
+ font-family: "Consolas", "Menlo", monospace;
+}
+</style>
+</head>
+<body>
+<h1>Lucy::Search::Query</h1>
+<h2>Name</h2>
+<p>Lucy::Search::Query - A specification for a search query.</p>
+<h2>Description</h2>
+<p>Query objects are simple containers which contain the minimum information
+necessary to define a search query.</p>
+<p>The most common way to generate Query objects is to feed a search string
+such as 'foo AND bar' to a <a href="lucy_QueryParser.html">QueryParser's</a>
+Parse() method, which outputs an abstract syntax tree built up from various
+Query subclasses such as <a href="lucy_ANDQuery.html">ANDQuery</a> and
+<a href="lucy_TermQuery.html">TermQuery</a>. However, it is also possible
+to use custom Query objects to build a search specification which cannot be
+easily represented using a search string.</p>
+<p>Subclasses of Query must implement Make_Compiler(), which is the first step
+in compiling a Query down to a <a href="lucy_Matcher.html">Matcher</a> which
+can actually match and score documents.</p>
+<h2>Functions</h2>
+<dl>
+<dt>init</dt>
+<dd>
+<pre><code>lucy_Query*
+<strong>lucy_Query_init</strong>(
+ lucy_Query* <strong>self</strong>,
+ float <strong>boost</strong>
+);
+</code></pre>
+<p>Abstract constructor.</p>
+<dl>
+<dt><emph>boost</emph></dt>
+<dd><p>A scoring multiplier, affecting the Query's relative
+contribution to each document's score. Typically defaults to 1.0, but
+subclasses which do not contribute to document scores such as NOTQuery
+and MatchAllQuery default to 0.0 instead.</p>
+</dd>
+</dl>
+</dd>
+</dl>
+<h2>Methods</h2>
+<h3>Abstract methods</h3>
+<dl>
+<dt>Make_Compiler</dt>
+<dd>
+<pre><code><a href="lucy_Compiler.html">lucy_Compiler*</a> // incremented
+<strong>LUCY_Query_Make_Compiler</strong>(
+ lucy_Query* <strong>self</strong>,
+ <a href="lucy_Searcher.html">lucy_Searcher*</a> <strong>searcher</strong>,
+ float <strong>boost</strong>,
+ bool <strong>subordinate</strong>
+);
+</code></pre>
+<p>Abstract factory method returning a Compiler derived from this Query.</p>
+<dl>
+<dt><emph>searcher</emph></dt>
+<dd><p>A Searcher.</p>
+</dd>
+<dt><emph>boost</emph></dt>
+<dd><p>A scoring multiplier.</p>
+</dd>
+<dt><emph>subordinate</emph></dt>
+<dd><p>Indicates whether the Query is a subquery (as
+opposed to a top-level query). If false, the implementation must
+invoke Normalize() on the newly minted Compiler object before returning
+it.</p>
+</dd>
+</dl>
+</dd>
+</dl>
+<h3>Novel methods</h3>
+<dl>
+<dt>Set_Boost</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_Query_Set_Boost</strong>(
+ lucy_Query* <strong>self</strong>,
+ float <strong>boost</strong>
+);
+</code></pre>
+<p>Set the Query's boost.</p>
+</dd>
+<dt>Get_Boost</dt>
+<dd>
+<pre><code>float
+<strong>LUCY_Query_Get_Boost</strong>(
+ lucy_Query* <strong>self</strong>
+);
+</code></pre>
+<p>Get the Query's boost.</p>
+</dd>
+<dt>Serialize</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_Query_Serialize</strong>(
+ lucy_Query* <strong>self</strong>,
+ <a href="lucy_OutStream.html">lucy_OutStream*</a> <strong>outstream</strong>
+);
+</code></pre>
+</dd>
+<dt>Deserialize</dt>
+<dd>
+<pre><code>lucy_Query* // incremented
+<strong>LUCY_Query_Deserialize</strong>(
+ lucy_Query* <strong>self</strong>, // decremented
+ <a href="lucy_InStream.html">lucy_InStream*</a> <strong>instream</strong>
+);
+</code></pre>
+</dd>
+<dt>Dump</dt>
+<dd>
+<pre><code><a href="cfish_Obj.html">cfish_Obj*</a> // incremented
+<strong>LUCY_Query_Dump</strong>(
+ lucy_Query* <strong>self</strong>
+);
+</code></pre>
+</dd>
+<dt>Load</dt>
+<dd>
+<pre><code><a href="cfish_Obj.html">cfish_Obj*</a> // incremented
+<strong>LUCY_Query_Load</strong>(
+ lucy_Query* <strong>self</strong>,
+ <a href="cfish_Obj.html">cfish_Obj*</a> <strong>dump</strong>
+);
+</code></pre>
+</dd>
+</dl>
+<h2>Inheritance</h2>
+<p>Lucy::Search::Query is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p>
+</body>
+</html>
Added: lucy/site/trunk/content/docs/c/lucy_QueryParser.html
URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/lucy_QueryParser.html?rev=1641230&view=auto
==============================================================================
--- lucy/site/trunk/content/docs/c/lucy_QueryParser.html (added)
+++ lucy/site/trunk/content/docs/c/lucy_QueryParser.html Sun Nov 23 17:42:57 2014
@@ -0,0 +1,324 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta name="viewport" content="width=device-width" />
+<style type="text/css">
+body {
+ font-family: sans-serif;
+ font-size: 0.85em;
+ max-width: 640px;
+}
+dt {
+ font-weight: bold;
+}
+pre {
+ border: 1px solid #000;
+ padding: 0.2em 0.4em;
+ background: #f6f6f6;
+ font-size: 1.2em;
+}
+code {
+ font-family: "Consolas", "Menlo", monospace;
+}
+</style>
+</head>
+<body>
+<h1>Lucy::Search::QueryParser</h1>
+<h2>Name</h2>
+<p>Lucy::Search::QueryParser - Transform a string into a Query object.</p>
+<h2>Description</h2>
+<p>QueryParser accepts search strings as input and produces
+<a href="lucy_Query.html">Query</a> objects, suitable for feeding into
+<a href="lucy_IndexSearcher.html">IndexSearcher</a> and other
+<a href="lucy_Searcher.html">Searcher</a> subclasses.</p>
+<p>The following syntactical constructs are recognized by QueryParser:</p>
+<ul>
+<li>Boolean operators 'AND', 'OR', and 'AND NOT'.</li>
+<li>Prepented +plus and -minus, indicating that the labeled entity
+should be either required or forbidden -- be it a single word, a
+phrase, or a parenthetical group.</li>
+<li>Logical groups, delimited by parentheses.</li>
+<li>Phrases, delimited by double quotes.</li>
+</ul>
+<p>Additionally, the following syntax can be enabled via Set_Heed_Colons():</p>
+<ul>
+<li>Field-specific constructs, in the form of 'fieldname:termtext' or
+'fieldname:(foo bar)'. (The field specified by 'fieldname:' will be
+used instead of the QueryParser's default fields).</li>
+</ul>
+<h2>Functions</h2>
+<dl>
+<dt>init</dt>
+<dd>
+<pre><code>lucy_QueryParser*
+<strong>lucy_QParser_init</strong>(
+ lucy_QueryParser* <strong>self</strong>,
+ <a href="lucy_Schema.html">lucy_Schema*</a> <strong>schema</strong>,
+ <a href="lucy_Analyzer.html">lucy_Analyzer*</a> <strong>analyzer</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>default_boolop</strong>,
+ <a href="cfish_VArray.html">cfish_VArray*</a> <strong>fields</strong>
+);
+</code></pre>
+<p>Constructor.</p>
+<dl>
+<dt><emph>schema</emph></dt>
+<dd><p>A <a href="lucy_Schema.html">Schema</a>.</p>
+</dd>
+<dt><emph>analyzer</emph></dt>
+<dd><p>An <a href="lucy_Analyzer.html">Analyzer</a>.
+Ordinarily, the analyzers specified by each field's definition will be
+used, but if <code>analyzer</code> is supplied, it will override and be used for
+all fields. This can lead to mismatches between what is in the index
+and what is being searched for, so use caution.</p>
+</dd>
+<dt><emph>fields</emph></dt>
+<dd><p>The names of the fields which will be searched against.
+Defaults to those fields which are defined as indexed in the supplied
+Schema.</p>
+</dd>
+<dt><emph>default_boolop</emph></dt>
+<dd><p>Two possible values: 'AND' and 'OR'. The default
+is 'OR', which means: return documents which match any of the query
+terms. If you want only documents which match all of the query terms,
+set this to 'AND'.</p>
+</dd>
+</dl>
+</dd>
+</dl>
+<h2>Methods</h2>
+<h3>Novel methods</h3>
+<dl>
+<dt>Parse</dt>
+<dd>
+<pre><code><a href="lucy_Query.html">lucy_Query*</a> // incremented
+<strong>LUCY_QParser_Parse</strong>(
+ lucy_QueryParser* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>query_string</strong>
+);
+</code></pre>
+<p>Build a Query object from the contents of a query string. At present,
+implemented internally by calling Tree(), Expand(), and Prune().</p>
+<dl>
+<dt><emph>query_string</emph></dt>
+<dd><p>The string to be parsed. May be NULL.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> a Query.</p>
+</dd>
+<dt>Tree</dt>
+<dd>
+<pre><code><a href="lucy_Query.html">lucy_Query*</a> // incremented
+<strong>LUCY_QParser_Tree</strong>(
+ lucy_QueryParser* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>query_string</strong>
+);
+</code></pre>
+<p>Parse the logical structure of a query string, building a tree
+comprised of Query objects. Leaf nodes in the tree will most often be
+LeafQuery objects but might be MatchAllQuery or NoMatchQuery objects as
+well. Internal nodes will be objects which subclass PolyQuery:
+ANDQuery, ORQuery, NOTQuery, and RequiredOptionalQuery.</p>
+<p>The output of Tree() is an intermediate form which must be passed
+through Expand() before being used to feed a search.</p>
+<dl>
+<dt><emph>query_string</emph></dt>
+<dd><p>The string to be parsed.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> a Query.</p>
+</dd>
+<dt>Expand</dt>
+<dd>
+<pre><code><a href="lucy_Query.html">lucy_Query*</a> // incremented
+<strong>LUCY_QParser_Expand</strong>(
+ lucy_QueryParser* <strong>self</strong>,
+ <a href="lucy_Query.html">lucy_Query*</a> <strong>query</strong>
+);
+</code></pre>
+<p>Walk the hierarchy of a Query tree, descending through all PolyQuery
+nodes and calling Expand_Leaf() on any LeafQuery nodes encountered.</p>
+<dl>
+<dt><emph>query</emph></dt>
+<dd><p>A Query object.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> A Query -- usually the same one that was supplied after
+in-place modification, but possibly another.</p>
+</dd>
+<dt>Expand_Leaf</dt>
+<dd>
+<pre><code><a href="lucy_Query.html">lucy_Query*</a> // incremented
+<strong>LUCY_QParser_Expand_Leaf</strong>(
+ lucy_QueryParser* <strong>self</strong>,
+ <a href="lucy_Query.html">lucy_Query*</a> <strong>query</strong>
+);
+</code></pre>
+<p>Convert a LeafQuery into either a TermQuery, a PhraseQuery, or an
+ORQuery joining multiple TermQueries/PhraseQueries to accommodate
+multiple fields. LeafQuery text will be passed through the relevant
+Analyzer for each field. Quoted text will be transformed into
+PhraseQuery objects. Unquoted text will be converted to either a
+TermQuery or a PhraseQuery depending on how many tokens are generated.</p>
+<dl>
+<dt><emph>query</emph></dt>
+<dd><p>A Query. Only LeafQuery objects will be processed; others
+will be passed through.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> A Query.</p>
+</dd>
+<dt>Prune</dt>
+<dd>
+<pre><code><a href="lucy_Query.html">lucy_Query*</a> // incremented
+<strong>LUCY_QParser_Prune</strong>(
+ lucy_QueryParser* <strong>self</strong>,
+ <a href="lucy_Query.html">lucy_Query*</a> <strong>query</strong>
+);
+</code></pre>
+<p>Prevent certain Query structures from returning too many results.
+Query objects built via Tree() and Expand() can generate "return the
+world" result sets, such as in the case of
+<code>NOT a_term_not_in_the_index</code>; Prune() walks the hierarchy
+and eliminates such branches.</p>
+<pre><code> 'NOT foo' => [NOMATCH]
+ 'foo OR NOT bar' => 'foo'
+ 'foo OR (-bar AND -baz) => 'foo'
+</code></pre>
+<p>Prune() also eliminates some double-negative constructs -- even though
+such constructs may not actually return the world:</p>
+<pre><code> 'foo AND -(-bar)' => 'foo'
+</code></pre>
+<p>In this example, safety is taking precedence over logical consistency.
+If you want logical consistency instead, call Tree() then Expand(),
+skipping Prune().</p>
+<dl>
+<dt><emph>query</emph></dt>
+<dd><p>A Query.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> a Query; in most cases, the supplied Query after in-place
+modification.</p>
+</dd>
+<dt>Make_Term_Query</dt>
+<dd>
+<pre><code><a href="lucy_Query.html">lucy_Query*</a> // incremented
+<strong>LUCY_QParser_Make_Term_Query</strong>(
+ lucy_QueryParser* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>field</strong>,
+ <a href="cfish_Obj.html">cfish_Obj*</a> <strong>term</strong>
+);
+</code></pre>
+<p>Factory method creating a TermQuery.</p>
+<dl>
+<dt><emph>field</emph></dt>
+<dd><p>Field name.</p>
+</dd>
+<dt><emph>term</emph></dt>
+<dd><p>Term text.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> A Query.</p>
+</dd>
+<dt>Make_Phrase_Query</dt>
+<dd>
+<pre><code><a href="lucy_Query.html">lucy_Query*</a> // incremented
+<strong>LUCY_QParser_Make_Phrase_Query</strong>(
+ lucy_QueryParser* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>field</strong>,
+ <a href="cfish_VArray.html">cfish_VArray*</a> <strong>terms</strong>
+);
+</code></pre>
+<p>Factory method creating a PhraseQuery.</p>
+<dl>
+<dt><emph>field</emph></dt>
+<dd><p>Field that the phrase must occur in.</p>
+</dd>
+<dt><emph>terms</emph></dt>
+<dd><p>Ordered array of terms that must match.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> A Query.</p>
+</dd>
+<dt>Make_OR_Query</dt>
+<dd>
+<pre><code><a href="lucy_Query.html">lucy_Query*</a> // incremented
+<strong>LUCY_QParser_Make_OR_Query</strong>(
+ lucy_QueryParser* <strong>self</strong>,
+ <a href="cfish_VArray.html">cfish_VArray*</a> <strong>children</strong>
+);
+</code></pre>
+<p>Factory method creating an ORQuery.</p>
+<dl>
+<dt><emph>children</emph></dt>
+<dd><p>Array of child Queries.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> A Query.</p>
+</dd>
+<dt>Make_AND_Query</dt>
+<dd>
+<pre><code><a href="lucy_Query.html">lucy_Query*</a> // incremented
+<strong>LUCY_QParser_Make_AND_Query</strong>(
+ lucy_QueryParser* <strong>self</strong>,
+ <a href="cfish_VArray.html">cfish_VArray*</a> <strong>children</strong>
+);
+</code></pre>
+<p>Factory method creating an ANDQuery.</p>
+<dl>
+<dt><emph>children</emph></dt>
+<dd><p>Array of child Queries.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> A Query.</p>
+</dd>
+<dt>Make_NOT_Query</dt>
+<dd>
+<pre><code><a href="lucy_Query.html">lucy_Query*</a> // incremented
+<strong>LUCY_QParser_Make_NOT_Query</strong>(
+ lucy_QueryParser* <strong>self</strong>,
+ <a href="lucy_Query.html">lucy_Query*</a> <strong>negated_query</strong>
+);
+</code></pre>
+<p>Factory method creating a NOTQuery.</p>
+<dl>
+<dt><emph>negated_query</emph></dt>
+<dd><p>Query to be inverted.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> A Query.</p>
+</dd>
+<dt>Make_Req_Opt_Query</dt>
+<dd>
+<pre><code><a href="lucy_Query.html">lucy_Query*</a> // incremented
+<strong>LUCY_QParser_Make_Req_Opt_Query</strong>(
+ lucy_QueryParser* <strong>self</strong>,
+ <a href="lucy_Query.html">lucy_Query*</a> <strong>required_query</strong>,
+ <a href="lucy_Query.html">lucy_Query*</a> <strong>optional_query</strong>
+);
+</code></pre>
+<p>Factory method creating a RequiredOptionalQuery.</p>
+<dl>
+<dt><emph>required_query</emph></dt>
+<dd><p>Query must must match.</p>
+</dd>
+<dt><emph>optional_query</emph></dt>
+<dd><p>Query which should match.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> A Query.</p>
+</dd>
+<dt>Set_Heed_Colons</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_QParser_Set_Heed_Colons</strong>(
+ lucy_QueryParser* <strong>self</strong>,
+ bool <strong>heed_colons</strong>
+);
+</code></pre>
+<p>Enable/disable parsing of <code>fieldname:foo</code> constructs.</p>
+</dd>
+</dl>
+<h2>Inheritance</h2>
+<p>Lucy::Search::QueryParser is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p>
+</body>
+</html>
Added: lucy/site/trunk/content/docs/c/lucy_RAMFolder.html
URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/lucy_RAMFolder.html?rev=1641230&view=auto
==============================================================================
--- lucy/site/trunk/content/docs/c/lucy_RAMFolder.html (added)
+++ lucy/site/trunk/content/docs/c/lucy_RAMFolder.html Sun Nov 23 17:42:57 2014
@@ -0,0 +1,280 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta name="viewport" content="width=device-width" />
+<style type="text/css">
+body {
+ font-family: sans-serif;
+ font-size: 0.85em;
+ max-width: 640px;
+}
+dt {
+ font-weight: bold;
+}
+pre {
+ border: 1px solid #000;
+ padding: 0.2em 0.4em;
+ background: #f6f6f6;
+ font-size: 1.2em;
+}
+code {
+ font-family: "Consolas", "Menlo", monospace;
+}
+</style>
+</head>
+<body>
+<h1>Lucy::Store::RAMFolder</h1>
+<h2>Name</h2>
+<p>Lucy::Store::RAMFolder - In-memory Folder implementation.</p>
+<h2>Description</h2>
+<p>RAMFolder is an entirely in-memory implementation of
+<a href="lucy_Folder.html">Folder</a>, primarily used for testing and development.</p>
+<h2>Functions</h2>
+<dl>
+<dt>init</dt>
+<dd>
+<pre><code>lucy_RAMFolder*
+<strong>lucy_RAMFolder_init</strong>(
+ lucy_RAMFolder* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>path</strong>
+);
+</code></pre>
+<dl>
+<dt><emph>path</emph></dt>
+<dd><p>Relative path, used for subfolders.</p>
+</dd>
+</dl>
+</dd>
+</dl>
+<h2>Methods</h2>
+<h3>Methods inherited from Lucy::Store::Folder</h3><dl>
+<dt>Get_Path</dt>
+<dd>
+<pre><code><a href="cfish_String.html">cfish_String*</a>
+<strong>LUCY_Folder_Get_Path</strong>(
+ lucy_Folder* <strong>self</strong>
+);
+</code></pre>
+<p>Getter for <code>path</code> member var.</p>
+</dd>
+<dt>Open_Out</dt>
+<dd>
+<pre><code><a href="lucy_OutStream.html">lucy_OutStream*</a> // incremented
+<strong>LUCY_Folder_Open_Out</strong>(
+ lucy_Folder* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>path</strong>
+);
+</code></pre>
+<p>Open an OutStream, or set Err_error and return NULL on failure.</p>
+<dl>
+<dt><emph>path</emph></dt>
+<dd><p>A relative filepath.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> an OutStream.</p>
+</dd>
+<dt>Open_In</dt>
+<dd>
+<pre><code><a href="lucy_InStream.html">lucy_InStream*</a> // incremented
+<strong>LUCY_Folder_Open_In</strong>(
+ lucy_Folder* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>path</strong>
+);
+</code></pre>
+<p>Open an InStream, or set Err_error and return NULL on failure.</p>
+<dl>
+<dt><emph>path</emph></dt>
+<dd><p>A relative filepath.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> an InStream.</p>
+</dd>
+<dt>Open_FileHandle</dt>
+<dd>
+<pre><code><a href="lucy_FileHandle.html">lucy_FileHandle*</a> // incremented
+<strong>LUCY_Folder_Open_FileHandle</strong>(
+ lucy_Folder* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>path</strong>,
+ uint32_t <strong>flags</strong>
+);
+</code></pre>
+<p>Open a FileHandle, or set Err_error and return NULL on failure.</p>
+<dl>
+<dt><emph>path</emph></dt>
+<dd><p>A relative filepath.</p>
+</dd>
+<dt><emph>flags</emph></dt>
+<dd><p>FileHandle flags.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> a FileHandle.</p>
+</dd>
+<dt>Open_Dir</dt>
+<dd>
+<pre><code><a href="lucy_DirHandle.html">lucy_DirHandle*</a> // incremented
+<strong>LUCY_Folder_Open_Dir</strong>(
+ lucy_Folder* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>path</strong>
+);
+</code></pre>
+<p>Open a DirHandle or set Err_error and return NULL on failure.</p>
+<dl>
+<dt><emph>path</emph></dt>
+<dd><p>Path to a subdirectory, relative to the Folder's path. If
+empty or NULL, returns a DirHandle for this Folder.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> a DirHandle.</p>
+</dd>
+<dt>MkDir</dt>
+<dd>
+<pre><code>bool
+<strong>LUCY_Folder_MkDir</strong>(
+ lucy_Folder* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>path</strong>
+);
+</code></pre>
+<p>Create a subdirectory.</p>
+<dl>
+<dt><emph>path</emph></dt>
+<dd><p>A relative filepath.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> true on success, false on failure (sets Err_error).</p>
+</dd>
+<dt>Exists</dt>
+<dd>
+<pre><code>bool
+<strong>LUCY_Folder_Exists</strong>(
+ lucy_Folder* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>path</strong>
+);
+</code></pre>
+<p>Indicate whether an entity exists at <code>path</code>.</p>
+<dl>
+<dt><emph>path</emph></dt>
+<dd><p>A relative filepath.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> true if <code>path</code> exists.</p>
+</dd>
+<dt>Delete</dt>
+<dd>
+<pre><code>bool
+<strong>LUCY_Folder_Delete</strong>(
+ lucy_Folder* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>path</strong>
+);
+</code></pre>
+<p>Delete an entry from the folder.</p>
+<dl>
+<dt><emph>path</emph></dt>
+<dd><p>A relative filepath.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> true if the deletion was successful.</p>
+</dd>
+<dt>Delete_Tree</dt>
+<dd>
+<pre><code>bool
+<strong>LUCY_Folder_Delete_Tree</strong>(
+ lucy_Folder* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>path</strong>
+);
+</code></pre>
+<p>Delete recursively, starting at <code>path</code></p>
+<dl>
+<dt><emph>path</emph></dt>
+<dd><p>A relative filepath specifying a file or subdirectory.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> true if the whole tree is deleted successfully, false if any
+part remains.</p>
+</dd>
+<dt>Rename</dt>
+<dd>
+<pre><code>bool
+<strong>LUCY_Folder_Rename</strong>(
+ lucy_Folder* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>from</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>to</strong>
+);
+</code></pre>
+<p>Rename a file or directory, or set Err_error and return false on
+failure. If an entry exists at <code>to</code>, the results are
+undefined.</p>
+<dl>
+<dt><emph>from</emph></dt>
+<dd><p>The filepath prior to renaming.</p>
+</dd>
+<dt><emph>to</emph></dt>
+<dd><p>The filepath after renaming.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> true on success, false on failure.</p>
+</dd>
+<dt>Hard_Link</dt>
+<dd>
+<pre><code>bool
+<strong>LUCY_Folder_Hard_Link</strong>(
+ lucy_Folder* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>from</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>to</strong>
+);
+</code></pre>
+<p>Create a hard link at path <code>to</code> pointing at the existing
+file <code>from</code>, or set Err_error and return false on failure.</p>
+<p><strong>Returns:</strong> true on success, false on failure.</p>
+</dd>
+<dt>Slurp_File</dt>
+<dd>
+<pre><code><a href="cfish_ByteBuf.html">cfish_ByteBuf*</a> // incremented
+<strong>LUCY_Folder_Slurp_File</strong>(
+ lucy_Folder* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>path</strong>
+);
+</code></pre>
+<p>Read a file and return its contents.</p>
+<dl>
+<dt><emph>path</emph></dt>
+<dd><p>A relative filepath.</p>
+</dd>
+<dt><emph>return</emph></dt>
+<dd><p>the file's contents.</p>
+</dd>
+</dl>
+</dd>
+<dt>Initialize</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_Folder_Initialize</strong>(
+ lucy_Folder* <strong>self</strong>
+);
+</code></pre>
+<p>Perform implementation-specific initialization. For example: FSFolder
+creates its own directory.</p>
+</dd>
+<dt>Check</dt>
+<dd>
+<pre><code>bool
+<strong>LUCY_Folder_Check</strong>(
+ lucy_Folder* <strong>self</strong>
+);
+</code></pre>
+<p>Verify that operations may be performed on this Folder.</p>
+<p><strong>Returns:</strong> true on success.</p>
+</dd>
+<dt>Close</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_Folder_Close</strong>(
+ lucy_Folder* <strong>self</strong>
+);
+</code></pre>
+<p>Close the folder and release implementation-specific resources.</p>
+</dd>
+</dl>
+<h2>Inheritance</h2>
+<p>Lucy::Store::RAMFolder is a <a href="lucy_Folder.html">Lucy::Store::Folder</a> is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p>
+</body>
+</html>
Added: lucy/site/trunk/content/docs/c/lucy_RangeQuery.html
URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/lucy_RangeQuery.html?rev=1641230&view=auto
==============================================================================
--- lucy/site/trunk/content/docs/c/lucy_RangeQuery.html (added)
+++ lucy/site/trunk/content/docs/c/lucy_RangeQuery.html Sun Nov 23 17:42:57 2014
@@ -0,0 +1,158 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta name="viewport" content="width=device-width" />
+<style type="text/css">
+body {
+ font-family: sans-serif;
+ font-size: 0.85em;
+ max-width: 640px;
+}
+dt {
+ font-weight: bold;
+}
+pre {
+ border: 1px solid #000;
+ padding: 0.2em 0.4em;
+ background: #f6f6f6;
+ font-size: 1.2em;
+}
+code {
+ font-family: "Consolas", "Menlo", monospace;
+}
+</style>
+</head>
+<body>
+<h1>Lucy::Search::RangeQuery</h1>
+<h2>Name</h2>
+<p>Lucy::Search::RangeQuery - Match a range of values.</p>
+<h2>Description</h2>
+<p>RangeQuery matches documents where the value for a particular field falls
+within a given range.</p>
+<h2>Functions</h2>
+<dl>
+<dt>init</dt>
+<dd>
+<pre><code>lucy_RangeQuery*
+<strong>lucy_RangeQuery_init</strong>(
+ lucy_RangeQuery* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>field</strong>,
+ <a href="cfish_Obj.html">cfish_Obj*</a> <strong>lower_term</strong>,
+ <a href="cfish_Obj.html">cfish_Obj*</a> <strong>upper_term</strong>,
+ bool <strong>include_lower</strong>,
+ bool <strong>include_upper</strong>
+);
+</code></pre>
+<p>Takes 5 parameters; <code>field</code> is required, as
+is at least one of either <code>lower_term</code> or
+<code>upper_term</code>.</p>
+<dl>
+<dt><emph>field</emph></dt>
+<dd><p>The name of a <code>sortable</code> field.</p>
+</dd>
+<dt><emph>lower_term</emph></dt>
+<dd><p>Lower delimiter. If not supplied, all values
+less than <code>upper_term</code> will pass.</p>
+</dd>
+<dt><emph>upper_term</emph></dt>
+<dd><p>Upper delimiter. If not supplied, all values greater
+than <code>lower_term</code> will pass.</p>
+</dd>
+<dt><emph>include_lower</emph></dt>
+<dd><p>Indicates whether docs which match
+<code>lower_term</code> should be included in the results.</p>
+</dd>
+<dt><emph>include_upper</emph></dt>
+<dd><p>Indicates whether docs which match
+<code>upper_term</code> should be included in the results.</p>
+</dd>
+</dl>
+</dd>
+</dl>
+<h2>Methods</h2>
+<h3>Methods inherited from Lucy::Search::Query</h3><dl>
+<dt>Make_Compiler</dt>
+<dd>
+<pre><code><a href="lucy_Compiler.html">lucy_Compiler*</a> // incremented
+<strong>LUCY_Query_Make_Compiler</strong>(
+ lucy_Query* <strong>self</strong>,
+ <a href="lucy_Searcher.html">lucy_Searcher*</a> <strong>searcher</strong>,
+ float <strong>boost</strong>,
+ bool <strong>subordinate</strong>
+);
+</code></pre>
+<p>Abstract factory method returning a Compiler derived from this Query.</p>
+<dl>
+<dt><emph>searcher</emph></dt>
+<dd><p>A Searcher.</p>
+</dd>
+<dt><emph>boost</emph></dt>
+<dd><p>A scoring multiplier.</p>
+</dd>
+<dt><emph>subordinate</emph></dt>
+<dd><p>Indicates whether the Query is a subquery (as
+opposed to a top-level query). If false, the implementation must
+invoke Normalize() on the newly minted Compiler object before returning
+it.</p>
+</dd>
+</dl>
+</dd>
+<dt>Set_Boost</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_Query_Set_Boost</strong>(
+ lucy_Query* <strong>self</strong>,
+ float <strong>boost</strong>
+);
+</code></pre>
+<p>Set the Query's boost.</p>
+</dd>
+<dt>Get_Boost</dt>
+<dd>
+<pre><code>float
+<strong>LUCY_Query_Get_Boost</strong>(
+ lucy_Query* <strong>self</strong>
+);
+</code></pre>
+<p>Get the Query's boost.</p>
+</dd>
+<dt>Serialize</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_Query_Serialize</strong>(
+ lucy_Query* <strong>self</strong>,
+ <a href="lucy_OutStream.html">lucy_OutStream*</a> <strong>outstream</strong>
+);
+</code></pre>
+</dd>
+<dt>Deserialize</dt>
+<dd>
+<pre><code>lucy_Query* // incremented
+<strong>LUCY_Query_Deserialize</strong>(
+ lucy_Query* <strong>self</strong>, // decremented
+ <a href="lucy_InStream.html">lucy_InStream*</a> <strong>instream</strong>
+);
+</code></pre>
+</dd>
+<dt>Dump</dt>
+<dd>
+<pre><code><a href="cfish_Obj.html">cfish_Obj*</a> // incremented
+<strong>LUCY_Query_Dump</strong>(
+ lucy_Query* <strong>self</strong>
+);
+</code></pre>
+</dd>
+<dt>Load</dt>
+<dd>
+<pre><code><a href="cfish_Obj.html">cfish_Obj*</a> // incremented
+<strong>LUCY_Query_Load</strong>(
+ lucy_Query* <strong>self</strong>,
+ <a href="cfish_Obj.html">cfish_Obj*</a> <strong>dump</strong>
+);
+</code></pre>
+</dd>
+</dl>
+<h2>Inheritance</h2>
+<p>Lucy::Search::RangeQuery is a <a href="lucy_Query.html">Lucy::Search::Query</a> is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p>
+</body>
+</html>
Added: lucy/site/trunk/content/docs/c/lucy_RegexTokenizer.html
URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/lucy_RegexTokenizer.html?rev=1641230&view=auto
==============================================================================
--- lucy/site/trunk/content/docs/c/lucy_RegexTokenizer.html (added)
+++ lucy/site/trunk/content/docs/c/lucy_RegexTokenizer.html Sun Nov 23 17:42:57 2014
@@ -0,0 +1,132 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta name="viewport" content="width=device-width" />
+<style type="text/css">
+body {
+ font-family: sans-serif;
+ font-size: 0.85em;
+ max-width: 640px;
+}
+dt {
+ font-weight: bold;
+}
+pre {
+ border: 1px solid #000;
+ padding: 0.2em 0.4em;
+ background: #f6f6f6;
+ font-size: 1.2em;
+}
+code {
+ font-family: "Consolas", "Menlo", monospace;
+}
+</style>
+</head>
+<body>
+<h1>Lucy::Analysis::RegexTokenizer</h1>
+<h2>Name</h2>
+<p>Lucy::Analysis::RegexTokenizer - Split a string into tokens.</p>
+<h2>Description</h2>
+<p>Generically, "tokenizing" is a process of breaking up a string into an
+array of "tokens". For instance, the string "three blind mice" might be
+tokenized into "three", "blind", "mice".</p>
+<p>Lucy::Analysis::RegexTokenizer decides where it should break up the text
+based on a regular expression compiled from a supplied <code>pattern</code>
+matching one token. If our source string is...</p>
+<pre><code>"Eats, Shoots and Leaves."
+</code></pre>
+<p>... then a "whitespace tokenizer" with a <code>pattern</code> of
+<code>"\\S+"</code> produces...</p>
+<pre><code>Eats,
+Shoots
+and
+Leaves.
+</code></pre>
+<p>... while a "word character tokenizer" with a <code>pattern</code> of
+<code>"\\w+"</code> produces...</p>
+<pre><code>Eats
+Shoots
+and
+Leaves
+</code></pre>
+<p>... the difference being that the word character tokenizer skips over
+punctuation as well as whitespace when determining token boundaries.</p>
+<h2>Functions</h2>
+<dl>
+<dt>init</dt>
+<dd>
+<pre><code>lucy_RegexTokenizer*
+<strong>lucy_RegexTokenizer_init</strong>(
+ lucy_RegexTokenizer* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>pattern</strong>
+);
+</code></pre>
+<dl>
+<dt><emph>pattern</emph></dt>
+<dd><p>A string specifying a Perl-syntax regular expression
+which should match one token. The default value is
+<code>\w+(?:[\x{2019}']\w+)*</code>, which matches "it's" as well as
+"it" and "O'Henry's" as well as "Henry".</p>
+</dd>
+</dl>
+</dd>
+</dl>
+<h2>Methods</h2>
+<h3>Methods inherited from Lucy::Analysis::Analyzer</h3><dl>
+<dt>Transform</dt>
+<dd>
+<pre><code><a href="lucy_Inversion.html">lucy_Inversion*</a> // incremented
+<strong>LUCY_Analyzer_Transform</strong>(
+ lucy_Analyzer* <strong>self</strong>,
+ <a href="lucy_Inversion.html">lucy_Inversion*</a> <strong>inversion</strong>
+);
+</code></pre>
+<p>Take a single <a href="lucy_Inversion.html">Inversion</a> as input
+and returns an Inversion, either the same one (presumably transformed
+in some way), or a new one.</p>
+</dd>
+<dt>Transform_Text</dt>
+<dd>
+<pre><code><a href="lucy_Inversion.html">lucy_Inversion*</a> // incremented
+<strong>LUCY_Analyzer_Transform_Text</strong>(
+ lucy_Analyzer* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>text</strong>
+);
+</code></pre>
+<p>Kick off an analysis chain, creating an Inversion from string input.
+The default implementation simply creates an initial Inversion with a
+single Token, then calls Transform(), but occasionally subclasses will
+provide an optimized implementation which minimizes string copies.</p>
+</dd>
+<dt>Split</dt>
+<dd>
+<pre><code><a href="cfish_VArray.html">cfish_VArray*</a> // incremented
+<strong>LUCY_Analyzer_Split</strong>(
+ lucy_Analyzer* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>text</strong>
+);
+</code></pre>
+<p>Analyze text and return an array of token texts.</p>
+</dd>
+<dt>Dump</dt>
+<dd>
+<pre><code><a href="cfish_Obj.html">cfish_Obj*</a> // incremented
+<strong>LUCY_Analyzer_Dump</strong>(
+ lucy_Analyzer* <strong>self</strong>
+);
+</code></pre>
+</dd>
+<dt>Load</dt>
+<dd>
+<pre><code><a href="cfish_Obj.html">cfish_Obj*</a> // incremented
+<strong>LUCY_Analyzer_Load</strong>(
+ lucy_Analyzer* <strong>self</strong>,
+ <a href="cfish_Obj.html">cfish_Obj*</a> <strong>dump</strong>
+);
+</code></pre>
+</dd>
+</dl>
+<h2>Inheritance</h2>
+<p>Lucy::Analysis::RegexTokenizer is a <a href="lucy_Analyzer.html">Lucy::Analysis::Analyzer</a> is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p>
+</body>
+</html>
Added: lucy/site/trunk/content/docs/c/lucy_RequiredOptionalQuery.html
URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/lucy_RequiredOptionalQuery.html?rev=1641230&view=auto
==============================================================================
--- lucy/site/trunk/content/docs/c/lucy_RequiredOptionalQuery.html (added)
+++ lucy/site/trunk/content/docs/c/lucy_RequiredOptionalQuery.html Sun Nov 23 17:42:57 2014
@@ -0,0 +1,193 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta name="viewport" content="width=device-width" />
+<style type="text/css">
+body {
+ font-family: sans-serif;
+ font-size: 0.85em;
+ max-width: 640px;
+}
+dt {
+ font-weight: bold;
+}
+pre {
+ border: 1px solid #000;
+ padding: 0.2em 0.4em;
+ background: #f6f6f6;
+ font-size: 1.2em;
+}
+code {
+ font-family: "Consolas", "Menlo", monospace;
+}
+</style>
+</head>
+<body>
+<h1>Lucy::Search::RequiredOptionalQuery</h1>
+<h2>Name</h2>
+<p>Lucy::Search::RequiredOptionalQuery - Join results for two Queries, one required, one optional.</p>
+<h2>Description</h2>
+<p>RequiredOptionalQuery joins the result sets of one Query which MUST match,
+and one Query which SHOULD match. When only the required Query matches,
+its score is passed along; when both match, the scores are summed.</p>
+<h2>Functions</h2>
+<dl>
+<dt>init</dt>
+<dd>
+<pre><code>lucy_RequiredOptionalQuery*
+<strong>lucy_ReqOptQuery_init</strong>(
+ lucy_RequiredOptionalQuery* <strong>self</strong>,
+ <a href="lucy_Query.html">lucy_Query*</a> <strong>required_query</strong>,
+ <a href="lucy_Query.html">lucy_Query*</a> <strong>optional_query</strong>
+);
+</code></pre>
+<dl>
+<dt><emph>required_query</emph></dt>
+<dd><p>Query must must match.</p>
+</dd>
+<dt><emph>optional_query</emph></dt>
+<dd><p>Query which should match.</p>
+</dd>
+</dl>
+</dd>
+</dl>
+<h2>Methods</h2>
+<h3>Novel methods</h3>
+<dl>
+<dt>Get_Required_Query</dt>
+<dd>
+<pre><code><a href="lucy_Query.html">lucy_Query*</a>
+<strong>LUCY_ReqOptQuery_Get_Required_Query</strong>(
+ lucy_RequiredOptionalQuery* <strong>self</strong>
+);
+</code></pre>
+<p>Getter for the required Query.</p>
+</dd>
+<dt>Set_Required_Query</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_ReqOptQuery_Set_Required_Query</strong>(
+ lucy_RequiredOptionalQuery* <strong>self</strong>,
+ <a href="lucy_Query.html">lucy_Query*</a> <strong>required_query</strong>
+);
+</code></pre>
+<p>Setter for the required Query.</p>
+</dd>
+<dt>Get_Optional_Query</dt>
+<dd>
+<pre><code><a href="lucy_Query.html">lucy_Query*</a>
+<strong>LUCY_ReqOptQuery_Get_Optional_Query</strong>(
+ lucy_RequiredOptionalQuery* <strong>self</strong>
+);
+</code></pre>
+<p>Getter for the optional Query.</p>
+</dd>
+<dt>Set_Optional_Query</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_ReqOptQuery_Set_Optional_Query</strong>(
+ lucy_RequiredOptionalQuery* <strong>self</strong>,
+ <a href="lucy_Query.html">lucy_Query*</a> <strong>optional_query</strong>
+);
+</code></pre>
+<p>Setter for the optional Query.</p>
+</dd>
+</dl>
+<h3>Methods inherited from Lucy::Search::PolyQuery</h3><dl>
+<dt>Add_Child</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_PolyQuery_Add_Child</strong>(
+ lucy_PolyQuery* <strong>self</strong>,
+ <a href="lucy_Query.html">lucy_Query*</a> <strong>query</strong>
+);
+</code></pre>
+<p>Add a child Query node.</p>
+</dd>
+</dl>
+<h3>Methods inherited from Lucy::Search::Query</h3><dl>
+<dt>Make_Compiler</dt>
+<dd>
+<pre><code><a href="lucy_Compiler.html">lucy_Compiler*</a> // incremented
+<strong>LUCY_Query_Make_Compiler</strong>(
+ lucy_Query* <strong>self</strong>,
+ <a href="lucy_Searcher.html">lucy_Searcher*</a> <strong>searcher</strong>,
+ float <strong>boost</strong>,
+ bool <strong>subordinate</strong>
+);
+</code></pre>
+<p>Abstract factory method returning a Compiler derived from this Query.</p>
+<dl>
+<dt><emph>searcher</emph></dt>
+<dd><p>A Searcher.</p>
+</dd>
+<dt><emph>boost</emph></dt>
+<dd><p>A scoring multiplier.</p>
+</dd>
+<dt><emph>subordinate</emph></dt>
+<dd><p>Indicates whether the Query is a subquery (as
+opposed to a top-level query). If false, the implementation must
+invoke Normalize() on the newly minted Compiler object before returning
+it.</p>
+</dd>
+</dl>
+</dd>
+<dt>Set_Boost</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_Query_Set_Boost</strong>(
+ lucy_Query* <strong>self</strong>,
+ float <strong>boost</strong>
+);
+</code></pre>
+<p>Set the Query's boost.</p>
+</dd>
+<dt>Get_Boost</dt>
+<dd>
+<pre><code>float
+<strong>LUCY_Query_Get_Boost</strong>(
+ lucy_Query* <strong>self</strong>
+);
+</code></pre>
+<p>Get the Query's boost.</p>
+</dd>
+<dt>Serialize</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_Query_Serialize</strong>(
+ lucy_Query* <strong>self</strong>,
+ <a href="lucy_OutStream.html">lucy_OutStream*</a> <strong>outstream</strong>
+);
+</code></pre>
+</dd>
+<dt>Deserialize</dt>
+<dd>
+<pre><code>lucy_Query* // incremented
+<strong>LUCY_Query_Deserialize</strong>(
+ lucy_Query* <strong>self</strong>, // decremented
+ <a href="lucy_InStream.html">lucy_InStream*</a> <strong>instream</strong>
+);
+</code></pre>
+</dd>
+<dt>Dump</dt>
+<dd>
+<pre><code><a href="cfish_Obj.html">cfish_Obj*</a> // incremented
+<strong>LUCY_Query_Dump</strong>(
+ lucy_Query* <strong>self</strong>
+);
+</code></pre>
+</dd>
+<dt>Load</dt>
+<dd>
+<pre><code><a href="cfish_Obj.html">cfish_Obj*</a> // incremented
+<strong>LUCY_Query_Load</strong>(
+ lucy_Query* <strong>self</strong>,
+ <a href="cfish_Obj.html">cfish_Obj*</a> <strong>dump</strong>
+);
+</code></pre>
+</dd>
+</dl>
+<h2>Inheritance</h2>
+<p>Lucy::Search::RequiredOptionalQuery is a <a href="lucy_PolyQuery.html">Lucy::Search::PolyQuery</a> is a <a href="lucy_Query.html">Lucy::Search::Query</a> is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p>
+</body>
+</html>
Added: lucy/site/trunk/content/docs/c/lucy_Schema.html
URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/lucy_Schema.html?rev=1641230&view=auto
==============================================================================
--- lucy/site/trunk/content/docs/c/lucy_Schema.html (added)
+++ lucy/site/trunk/content/docs/c/lucy_Schema.html Sun Nov 23 17:42:57 2014
@@ -0,0 +1,166 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta name="viewport" content="width=device-width" />
+<style type="text/css">
+body {
+ font-family: sans-serif;
+ font-size: 0.85em;
+ max-width: 640px;
+}
+dt {
+ font-weight: bold;
+}
+pre {
+ border: 1px solid #000;
+ padding: 0.2em 0.4em;
+ background: #f6f6f6;
+ font-size: 1.2em;
+}
+code {
+ font-family: "Consolas", "Menlo", monospace;
+}
+</style>
+</head>
+<body>
+<h1>Lucy::Plan::Schema</h1>
+<h2>Name</h2>
+<p>Lucy::Plan::Schema - User-created specification for an inverted index.</p>
+<h2>Description</h2>
+<p>A Schema is a specification which indicates how other entities should
+interpret the raw data in an inverted index and interact with it.</p>
+<p>Once an actual index has been created using a particular Schema, existing
+field definitions may not be changed. However, it is possible to add new
+fields during subsequent indexing sessions.</p>
+<h2>Functions</h2>
+<dl>
+<dt>new</dt>
+<dd>
+<pre><code>lucy_Schema* // incremented
+<strong>lucy_Schema_new</strong>(void);
+</code></pre>
+</dd>
+<dt>init</dt>
+<dd>
+<pre><code>lucy_Schema*
+<strong>lucy_Schema_init</strong>(
+ lucy_Schema* <strong>self</strong>
+);
+</code></pre>
+<p>Constructor. Takes no arguments.</p>
+</dd>
+</dl>
+<h2>Methods</h2>
+<h3>Novel methods</h3>
+<dl>
+<dt>Architecture</dt>
+<dd>
+<pre><code><a href="lucy_Architecture.html">lucy_Architecture*</a> // incremented
+<strong>LUCY_Schema_Architecture</strong>(
+ lucy_Schema* <strong>self</strong>
+);
+</code></pre>
+<p>Factory method which creates an Architecture object for this index.</p>
+</dd>
+<dt>Spec_Field</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_Schema_Spec_Field</strong>(
+ lucy_Schema* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>name</strong>,
+ <a href="lucy_FieldType.html">lucy_FieldType*</a> <strong>type</strong>
+);
+</code></pre>
+<p>Define the behavior of a field by associating it with a FieldType.</p>
+<p>If this method has already been called for the supplied
+<code>field</code>, it will merely test to verify that the supplied
+FieldType Equals() the existing one.</p>
+<dl>
+<dt><emph>name</emph></dt>
+<dd><p>The name of the field.</p>
+</dd>
+<dt><emph>type</emph></dt>
+<dd><p>A FieldType.</p>
+</dd>
+</dl>
+</dd>
+<dt>Fetch_Type</dt>
+<dd>
+<pre><code><a href="lucy_FieldType.html">lucy_FieldType*</a>
+<strong>LUCY_Schema_Fetch_Type</strong>(
+ lucy_Schema* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>field</strong>
+);
+</code></pre>
+<p>Return the FieldType for the specified field. If the field can't be
+found, return NULL.</p>
+</dd>
+<dt>Fetch_Sim</dt>
+<dd>
+<pre><code><a href="lucy_Similarity.html">lucy_Similarity*</a>
+<strong>LUCY_Schema_Fetch_Sim</strong>(
+ lucy_Schema* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>field</strong>
+);
+</code></pre>
+<p>Return the Similarity for the specified field, or NULL if either the
+field can't be found or it isn't associated with a Similarity.</p>
+</dd>
+<dt>Num_Fields</dt>
+<dd>
+<pre><code>uint32_t
+<strong>LUCY_Schema_Num_Fields</strong>(
+ lucy_Schema* <strong>self</strong>
+);
+</code></pre>
+<p>Return the number of fields currently defined.</p>
+</dd>
+<dt>All_Fields</dt>
+<dd>
+<pre><code><a href="cfish_VArray.html">cfish_VArray*</a> // incremented
+<strong>LUCY_Schema_All_Fields</strong>(
+ lucy_Schema* <strong>self</strong>
+);
+</code></pre>
+<p>Return all the Schema's field names as an array.</p>
+</dd>
+<dt>Get_Architecture</dt>
+<dd>
+<pre><code><a href="lucy_Architecture.html">lucy_Architecture*</a>
+<strong>LUCY_Schema_Get_Architecture</strong>(
+ lucy_Schema* <strong>self</strong>
+);
+</code></pre>
+<p>Return the Schema instance's internal Architecture object.</p>
+</dd>
+<dt>Get_Similarity</dt>
+<dd>
+<pre><code><a href="lucy_Similarity.html">lucy_Similarity*</a>
+<strong>LUCY_Schema_Get_Similarity</strong>(
+ lucy_Schema* <strong>self</strong>
+);
+</code></pre>
+<p>Return the Schema instance's internal Similarity object.</p>
+</dd>
+<dt>Dump</dt>
+<dd>
+<pre><code><a href="cfish_Hash.html">cfish_Hash*</a> // incremented
+<strong>LUCY_Schema_Dump</strong>(
+ lucy_Schema* <strong>self</strong>
+);
+</code></pre>
+</dd>
+<dt>Load</dt>
+<dd>
+<pre><code>lucy_Schema* // incremented
+<strong>LUCY_Schema_Load</strong>(
+ lucy_Schema* <strong>self</strong>,
+ <a href="cfish_Obj.html">cfish_Obj*</a> <strong>dump</strong>
+);
+</code></pre>
+</dd>
+</dl>
+<h2>Inheritance</h2>
+<p>Lucy::Plan::Schema is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p>
+</body>
+</html>
Added: lucy/site/trunk/content/docs/c/lucy_Searcher.html
URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/lucy_Searcher.html?rev=1641230&view=auto
==============================================================================
--- lucy/site/trunk/content/docs/c/lucy_Searcher.html (added)
+++ lucy/site/trunk/content/docs/c/lucy_Searcher.html Sun Nov 23 17:42:57 2014
@@ -0,0 +1,181 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta name="viewport" content="width=device-width" />
+<style type="text/css">
+body {
+ font-family: sans-serif;
+ font-size: 0.85em;
+ max-width: 640px;
+}
+dt {
+ font-weight: bold;
+}
+pre {
+ border: 1px solid #000;
+ padding: 0.2em 0.4em;
+ background: #f6f6f6;
+ font-size: 1.2em;
+}
+code {
+ font-family: "Consolas", "Menlo", monospace;
+}
+</style>
+</head>
+<body>
+<h1>Lucy::Search::Searcher</h1>
+<h2>Name</h2>
+<p>Lucy::Search::Searcher - Base class for searching collections of documents.</p>
+<h2>Description</h2>
+<p>Abstract base class for objects which search. Core subclasses include
+<a href="lucy_IndexSearcher.html">IndexSearcher</a> and
+<a href="lucy_PolySearcher.html">PolySearcher</a>.</p>
+<h2>Functions</h2>
+<dl>
+<dt>init</dt>
+<dd>
+<pre><code>lucy_Searcher*
+<strong>lucy_Searcher_init</strong>(
+ lucy_Searcher* <strong>self</strong>,
+ <a href="lucy_Schema.html">lucy_Schema*</a> <strong>schema</strong>
+);
+</code></pre>
+<p>Abstract constructor.</p>
+<dl>
+<dt><emph>schema</emph></dt>
+<dd><p>A Schema.</p>
+</dd>
+</dl>
+</dd>
+</dl>
+<h2>Methods</h2>
+<h3>Abstract methods</h3>
+<dl>
+<dt>Doc_Max</dt>
+<dd>
+<pre><code>int32_t
+<strong>LUCY_Searcher_Doc_Max</strong>(
+ lucy_Searcher* <strong>self</strong>
+);
+</code></pre>
+<p>Return the maximum number of docs in the collection represented by the
+Searcher, which is also the highest possible internal doc id.
+Documents which have been marked as deleted but not yet purged are
+included in this count.</p>
+</dd>
+<dt>Doc_Freq</dt>
+<dd>
+<pre><code>uint32_t
+<strong>LUCY_Searcher_Doc_Freq</strong>(
+ lucy_Searcher* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>field</strong>,
+ <a href="cfish_Obj.html">cfish_Obj*</a> <strong>term</strong>
+);
+</code></pre>
+<p>Return the number of documents which contain the term in the given
+field.</p>
+<dl>
+<dt><emph>field</emph></dt>
+<dd><p>Field name.</p>
+</dd>
+<dt><emph>term</emph></dt>
+<dd><p>The term to look up.</p>
+</dd>
+</dl>
+</dd>
+<dt>Collect</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_Searcher_Collect</strong>(
+ lucy_Searcher* <strong>self</strong>,
+ <a href="lucy_Query.html">lucy_Query*</a> <strong>query</strong>,
+ <a href="lucy_Collector.html">lucy_Collector*</a> <strong>collector</strong>
+);
+</code></pre>
+<p>Iterate over hits, feeding them into a
+<a href="lucy_Collector.html">Collector</a>.</p>
+<dl>
+<dt><emph>query</emph></dt>
+<dd><p>A Query.</p>
+</dd>
+<dt><emph>collector</emph></dt>
+<dd><p>A Collector.</p>
+</dd>
+</dl>
+</dd>
+<dt>Fetch_Doc</dt>
+<dd>
+<pre><code><a href="lucy_HitDoc.html">lucy_HitDoc*</a> // incremented
+<strong>LUCY_Searcher_Fetch_Doc</strong>(
+ lucy_Searcher* <strong>self</strong>,
+ int32_t <strong>doc_id</strong>
+);
+</code></pre>
+<p>Retrieve a document. Throws an error if the doc id is out of range.</p>
+<dl>
+<dt><emph>doc_id</emph></dt>
+<dd><p>A document id.</p>
+</dd>
+</dl>
+</dd>
+</dl>
+<h3>Novel methods</h3>
+<dl>
+<dt>Glean_Query</dt>
+<dd>
+<pre><code><a href="lucy_Query.html">lucy_Query*</a> // incremented
+<strong>LUCY_Searcher_Glean_Query</strong>(
+ lucy_Searcher* <strong>self</strong>,
+ <a href="cfish_Obj.html">cfish_Obj*</a> <strong>query</strong>
+);
+</code></pre>
+<p>If the supplied object is a Query, return it; if it's a query string,
+create a QueryParser and parse it to produce a query against all
+indexed fields.</p>
+</dd>
+<dt>Hits</dt>
+<dd>
+<pre><code><a href="lucy_Hits.html">lucy_Hits*</a> // incremented
+<strong>LUCY_Searcher_Hits</strong>(
+ lucy_Searcher* <strong>self</strong>,
+ <a href="cfish_Obj.html">cfish_Obj*</a> <strong>query</strong>,
+ uint32_t <strong>offset</strong>,
+ uint32_t <strong>num_wanted</strong>,
+ <a href="lucy_SortSpec.html">lucy_SortSpec*</a> <strong>sort_spec</strong>
+);
+</code></pre>
+<p>Return a Hits object containing the top results.</p>
+<dl>
+<dt><emph>query</emph></dt>
+<dd><p>Either a Query object or a query string.</p>
+</dd>
+<dt><emph>offset</emph></dt>
+<dd><p>The number of most-relevant hits to discard, typically
+used when "paging" through hits N at a time. Setting
+<code>offset</code> to 20 and <code>num_wanted</code> to 10 retrieves
+hits 21-30, assuming that 30 hits can be found.</p>
+</dd>
+<dt><emph>num_wanted</emph></dt>
+<dd><p>The number of hits you would like to see after
+<code>offset</code> is taken into account.</p>
+</dd>
+<dt><emph>sort_spec</emph></dt>
+<dd><p>A <a href="lucy_SortSpec.html">SortSpec</a>, which will affect
+how results are ranked and returned.</p>
+</dd>
+</dl>
+</dd>
+<dt>Get_Schema</dt>
+<dd>
+<pre><code><a href="lucy_Schema.html">lucy_Schema*</a>
+<strong>LUCY_Searcher_Get_Schema</strong>(
+ lucy_Searcher* <strong>self</strong>
+);
+</code></pre>
+<p>Accessor for the object's <code>schema</code> member.</p>
+</dd>
+</dl>
+<h2>Inheritance</h2>
+<p>Lucy::Search::Searcher is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p>
+</body>
+</html>
Added: lucy/site/trunk/content/docs/c/lucy_SegReader.html
URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/lucy_SegReader.html?rev=1641230&view=auto
==============================================================================
--- lucy/site/trunk/content/docs/c/lucy_SegReader.html (added)
+++ lucy/site/trunk/content/docs/c/lucy_SegReader.html Sun Nov 23 17:42:57 2014
@@ -0,0 +1,256 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta name="viewport" content="width=device-width" />
+<style type="text/css">
+body {
+ font-family: sans-serif;
+ font-size: 0.85em;
+ max-width: 640px;
+}
+dt {
+ font-weight: bold;
+}
+pre {
+ border: 1px solid #000;
+ padding: 0.2em 0.4em;
+ background: #f6f6f6;
+ font-size: 1.2em;
+}
+code {
+ font-family: "Consolas", "Menlo", monospace;
+}
+</style>
+</head>
+<body>
+<h1>Lucy::Index::SegReader</h1>
+<h2>Name</h2>
+<p>Lucy::Index::SegReader - Single-segment IndexReader.</p>
+<h2>Description</h2>
+<p>SegReader interprets the data within a single segment of an index.</p>
+<p>Generally speaking, only advanced users writing subclasses which manipulate
+data at the segment level need to deal with the SegReader API directly.</p>
+<p>Nearly all of SegReader's functionality is implemented by pluggable
+components spawned by <a href="lucy_Architecture.html">Architecture</a>'s
+factory methods.</p>
+<h2>Methods</h2>
+<h3>Novel methods</h3>
+<dl>
+<dt>Register</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_SegReader_Register</strong>(
+ lucy_SegReader* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>api</strong>,
+ <a href="lucy_DataReader.html">lucy_DataReader*</a> <strong>component</strong> // decremented
+);
+</code></pre>
+<p>Add a component to the SegReader. Using the same <code>api</code> key
+twice is an error.</p>
+<dl>
+<dt><emph>api</emph></dt>
+<dd><p>The name of the DataReader subclass that defines the
+interface implemented by <code>component</code>.</p>
+</dd>
+<dt><emph>component</emph></dt>
+<dd><p>A DataReader.</p>
+</dd>
+</dl>
+</dd>
+<dt>Get_Seg_Name</dt>
+<dd>
+<pre><code><a href="cfish_String.html">cfish_String*</a>
+<strong>LUCY_SegReader_Get_Seg_Name</strong>(
+ lucy_SegReader* <strong>self</strong>
+);
+</code></pre>
+<p>Return the name of the segment.</p>
+</dd>
+<dt>Get_Seg_Num</dt>
+<dd>
+<pre><code>int64_t
+<strong>LUCY_SegReader_Get_Seg_Num</strong>(
+ lucy_SegReader* <strong>self</strong>
+);
+</code></pre>
+<p>Return the number of the segment.</p>
+</dd>
+</dl>
+<h3>Methods inherited from Lucy::Index::IndexReader</h3><dl>
+<dt>Doc_Max</dt>
+<dd>
+<pre><code>int32_t
+<strong>LUCY_IxReader_Doc_Max</strong>(
+ lucy_IndexReader* <strong>self</strong>
+);
+</code></pre>
+<p>Return the maximum number of documents available to the reader, which
+is also the highest possible internal document id. Documents which
+have been marked as deleted but not yet purged from the index are
+included in this count.</p>
+</dd>
+<dt>Doc_Count</dt>
+<dd>
+<pre><code>int32_t
+<strong>LUCY_IxReader_Doc_Count</strong>(
+ lucy_IndexReader* <strong>self</strong>
+);
+</code></pre>
+<p>Return the number of documents available to the reader, subtracting
+any that are marked as deleted.</p>
+</dd>
+<dt>Del_Count</dt>
+<dd>
+<pre><code>int32_t
+<strong>LUCY_IxReader_Del_Count</strong>(
+ lucy_IndexReader* <strong>self</strong>
+);
+</code></pre>
+<p>Return the number of documents which have been marked as deleted but
+not yet purged from the index.</p>
+</dd>
+<dt>Offsets</dt>
+<dd>
+<pre><code><a href="lucy_I32Array.html">lucy_I32Array*</a> // incremented
+<strong>LUCY_IxReader_Offsets</strong>(
+ lucy_IndexReader* <strong>self</strong>
+);
+</code></pre>
+<p>Return an array with one entry for each segment, corresponding to
+segment doc_id start offset.</p>
+</dd>
+<dt>Seg_Readers</dt>
+<dd>
+<pre><code><a href="cfish_VArray.html">cfish_VArray*</a> // incremented
+<strong>LUCY_IxReader_Seg_Readers</strong>(
+ lucy_IndexReader* <strong>self</strong>
+);
+</code></pre>
+<p>Return an array of all the SegReaders represented within the
+IndexReader.</p>
+</dd>
+<dt>Obtain</dt>
+<dd>
+<pre><code><a href="lucy_DataReader.html">lucy_DataReader*</a>
+<strong>LUCY_IxReader_Obtain</strong>(
+ lucy_IndexReader* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>api</strong>
+);
+</code></pre>
+<p>Fetch a component, or throw an error if the component can't be found.</p>
+<dl>
+<dt><emph>api</emph></dt>
+<dd><p>The name of the DataReader subclass that the desired
+component must implement.</p>
+</dd>
+</dl>
+</dd>
+<dt>Fetch</dt>
+<dd>
+<pre><code><a href="lucy_DataReader.html">lucy_DataReader*</a>
+<strong>LUCY_IxReader_Fetch</strong>(
+ lucy_IndexReader* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>api</strong>
+);
+</code></pre>
+<p>Fetch a component, or return NULL if the component can't be found.</p>
+<dl>
+<dt><emph>api</emph></dt>
+<dd><p>The name of the DataReader subclass that the desired
+component must implement.</p>
+</dd>
+</dl>
+</dd>
+</dl>
+<h3>Methods inherited from Lucy::Index::DataReader</h3><dl>
+<dt>Aggregator</dt>
+<dd>
+<pre><code>lucy_DataReader* // incremented
+<strong>LUCY_DataReader_Aggregator</strong>(
+ lucy_DataReader* <strong>self</strong>,
+ <a href="cfish_VArray.html">cfish_VArray*</a> <strong>readers</strong>,
+ <a href="lucy_I32Array.html">lucy_I32Array*</a> <strong>offsets</strong>
+);
+</code></pre>
+<p>Create a reader which aggregates the output of several lower level
+readers. Return NULL if such a reader is not valid.</p>
+<dl>
+<dt><emph>readers</emph></dt>
+<dd><p>An array of DataReaders.</p>
+</dd>
+<dt><emph>offsets</emph></dt>
+<dd><p>Doc id start offsets for each reader.</p>
+</dd>
+</dl>
+</dd>
+<dt>Get_Schema</dt>
+<dd>
+<pre><code><a href="lucy_Schema.html">lucy_Schema*</a>
+<strong>LUCY_DataReader_Get_Schema</strong>(
+ lucy_DataReader* <strong>self</strong>
+);
+</code></pre>
+<p>Accessor for "schema" member var.</p>
+</dd>
+<dt>Get_Folder</dt>
+<dd>
+<pre><code><a href="lucy_Folder.html">lucy_Folder*</a>
+<strong>LUCY_DataReader_Get_Folder</strong>(
+ lucy_DataReader* <strong>self</strong>
+);
+</code></pre>
+<p>Accessor for "folder" member var.</p>
+</dd>
+<dt>Get_Snapshot</dt>
+<dd>
+<pre><code><a href="lucy_Snapshot.html">lucy_Snapshot*</a>
+<strong>LUCY_DataReader_Get_Snapshot</strong>(
+ lucy_DataReader* <strong>self</strong>
+);
+</code></pre>
+<p>Accessor for "snapshot" member var.</p>
+</dd>
+<dt>Get_Segments</dt>
+<dd>
+<pre><code><a href="cfish_VArray.html">cfish_VArray*</a>
+<strong>LUCY_DataReader_Get_Segments</strong>(
+ lucy_DataReader* <strong>self</strong>
+);
+</code></pre>
+<p>Accessor for "segments" member var.</p>
+</dd>
+<dt>Get_Segment</dt>
+<dd>
+<pre><code><a href="lucy_Segment.html">lucy_Segment*</a>
+<strong>LUCY_DataReader_Get_Segment</strong>(
+ lucy_DataReader* <strong>self</strong>
+);
+</code></pre>
+<p>Accessor for "segment" member var.</p>
+</dd>
+<dt>Get_Seg_Tick</dt>
+<dd>
+<pre><code>int32_t
+<strong>LUCY_DataReader_Get_Seg_Tick</strong>(
+ lucy_DataReader* <strong>self</strong>
+);
+</code></pre>
+<p>Accessor for "seg_tick" member var.</p>
+</dd>
+<dt>Close</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_DataReader_Close</strong>(
+ lucy_DataReader* <strong>self</strong>
+);
+</code></pre>
+<p>Release external resources, e.g. streams. Implementations must be
+safe for multiple calls. Once called, no other operations may be
+performed upon either the reader or any component subreaders other than
+object destruction.</p>
+</dd>
+</dl>
+<h2>Inheritance</h2>
+<p>Lucy::Index::SegReader is a <a href="lucy_IndexReader.html">Lucy::Index::IndexReader</a> is a <a href="lucy_DataReader.html">Lucy::Index::DataReader</a> is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p>
+</body>
+</html>
Added: lucy/site/trunk/content/docs/c/lucy_SegWriter.html
URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/lucy_SegWriter.html?rev=1641230&view=auto
==============================================================================
--- lucy/site/trunk/content/docs/c/lucy_SegWriter.html (added)
+++ lucy/site/trunk/content/docs/c/lucy_SegWriter.html Sun Nov 23 17:42:57 2014
@@ -0,0 +1,272 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta name="viewport" content="width=device-width" />
+<style type="text/css">
+body {
+ font-family: sans-serif;
+ font-size: 0.85em;
+ max-width: 640px;
+}
+dt {
+ font-weight: bold;
+}
+pre {
+ border: 1px solid #000;
+ padding: 0.2em 0.4em;
+ background: #f6f6f6;
+ font-size: 1.2em;
+}
+code {
+ font-family: "Consolas", "Menlo", monospace;
+}
+</style>
+</head>
+<body>
+<h1>Lucy::Index::SegWriter</h1>
+<h2>Name</h2>
+<p>Lucy::Index::SegWriter - Write one segment of an index.</p>
+<h2>Description</h2>
+<p>SegWriter is a conduit through which information fed to Indexer passes. It
+manages <a href="lucy_Segment.html">Segment</a> and Inverter, invokes the
+<a href="lucy_Analyzer.html">Analyzer</a> chain, and feeds low
+level <a href="lucy_DataWriter.html">DataWriters</a> such as
+PostingListWriter and DocWriter.</p>
+<p>The sub-components of a SegWriter are determined by
+<a href="lucy_Architecture.html">Architecture</a>. DataWriter components
+which are added to the stack of writers via Add_Writer() have
+Add_Inverted_Doc() invoked for each document supplied to SegWriter's
+Add_Doc().</p>
+<h2>Methods</h2>
+<h3>Novel methods</h3>
+<dl>
+<dt>Register</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_SegWriter_Register</strong>(
+ lucy_SegWriter* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>api</strong>,
+ <a href="lucy_DataWriter.html">lucy_DataWriter*</a> <strong>component</strong> // decremented
+);
+</code></pre>
+<p>Register a DataWriter component with the SegWriter. (Note that
+registration simply makes the writer available via Fetch(), so you may
+also want to call Add_Writer()).</p>
+<dl>
+<dt><emph>api</emph></dt>
+<dd><p>The name of the DataWriter api which <code>writer</code>
+implements.</p>
+</dd>
+<dt><emph>component</emph></dt>
+<dd><p>A DataWriter.</p>
+</dd>
+</dl>
+</dd>
+<dt>Fetch</dt>
+<dd>
+<pre><code><a href="cfish_Obj.html">cfish_Obj*</a>
+<strong>LUCY_SegWriter_Fetch</strong>(
+ lucy_SegWriter* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>api</strong>
+);
+</code></pre>
+<p>Retrieve a registered component.</p>
+<dl>
+<dt><emph>api</emph></dt>
+<dd><p>The name of the DataWriter api which the component
+implements.</p>
+</dd>
+</dl>
+</dd>
+<dt>Add_Writer</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_SegWriter_Add_Writer</strong>(
+ lucy_SegWriter* <strong>self</strong>,
+ <a href="lucy_DataWriter.html">lucy_DataWriter*</a> <strong>writer</strong> // decremented
+);
+</code></pre>
+<p>Add a DataWriter to the SegWriter's stack of writers.</p>
+</dd>
+<dt>Add_Doc</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_SegWriter_Add_Doc</strong>(
+ lucy_SegWriter* <strong>self</strong>,
+ <a href="lucy_Doc.html">lucy_Doc*</a> <strong>doc</strong>,
+ float <strong>boost</strong>
+);
+</code></pre>
+<p>Add a document to the segment. Inverts <code>doc</code>, increments
+the Segment's internal document id, then calls Add_Inverted_Doc(),
+feeding all sub-writers.</p>
+</dd>
+</dl>
+<h3>Methods inherited from Lucy::Index::DataWriter</h3><dl>
+<dt>Add_Inverted_Doc</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_DataWriter_Add_Inverted_Doc</strong>(
+ lucy_DataWriter* <strong>self</strong>,
+ <a href="lucy_Inverter.html">lucy_Inverter*</a> <strong>inverter</strong>,
+ int32_t <strong>doc_id</strong>
+);
+</code></pre>
+<p>Process a document, previously inverted by <code>inverter</code>.</p>
+<dl>
+<dt><emph>inverter</emph></dt>
+<dd><p>An Inverter wrapping an inverted document.</p>
+</dd>
+<dt><emph>doc_id</emph></dt>
+<dd><p>Internal number assigned to this document within the
+segment.</p>
+</dd>
+</dl>
+</dd>
+<dt>Add_Segment</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_DataWriter_Add_Segment</strong>(
+ lucy_DataWriter* <strong>self</strong>,
+ <a href="lucy_SegReader.html">lucy_SegReader*</a> <strong>reader</strong>,
+ <a href="lucy_I32Array.html">lucy_I32Array*</a> <strong>doc_map</strong>
+);
+</code></pre>
+<p>Add content from an existing segment into the one currently being
+written.</p>
+<dl>
+<dt><emph>reader</emph></dt>
+<dd><p>The SegReader containing content to add.</p>
+</dd>
+<dt><emph>doc_map</emph></dt>
+<dd><p>An array of integers mapping old document ids to
+new. Deleted documents are mapped to 0, indicating that they should be
+skipped.</p>
+</dd>
+</dl>
+</dd>
+<dt>Delete_Segment</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_DataWriter_Delete_Segment</strong>(
+ lucy_DataWriter* <strong>self</strong>,
+ <a href="lucy_SegReader.html">lucy_SegReader*</a> <strong>reader</strong>
+);
+</code></pre>
+<p>Remove a segment's data. The default implementation is a no-op, as
+all files within the segment directory will be automatically deleted.
+Subclasses which manage their own files outside of the segment system
+should override this method and use it as a trigger for cleaning up
+obsolete data.</p>
+<dl>
+<dt><emph>reader</emph></dt>
+<dd><p>The SegReader containing content to merge, which must
+represent a segment which is part of the the current snapshot.</p>
+</dd>
+</dl>
+</dd>
+<dt>Merge_Segment</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_DataWriter_Merge_Segment</strong>(
+ lucy_DataWriter* <strong>self</strong>,
+ <a href="lucy_SegReader.html">lucy_SegReader*</a> <strong>reader</strong>,
+ <a href="lucy_I32Array.html">lucy_I32Array*</a> <strong>doc_map</strong>
+);
+</code></pre>
+<p>Move content from an existing segment into the one currently being
+written.</p>
+<p>The default implementation calls Add_Segment() then Delete_Segment().</p>
+<dl>
+<dt><emph>reader</emph></dt>
+<dd><p>The SegReader containing content to merge, which must
+represent a segment which is part of the the current snapshot.</p>
+</dd>
+<dt><emph>doc_map</emph></dt>
+<dd><p>An array of integers mapping old document ids to
+new. Deleted documents are mapped to 0, indicating that they should be
+skipped.</p>
+</dd>
+</dl>
+</dd>
+<dt>Finish</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_DataWriter_Finish</strong>(
+ lucy_DataWriter* <strong>self</strong>
+);
+</code></pre>
+<p>Complete the segment: close all streams, store metadata, etc.</p>
+</dd>
+<dt>Metadata</dt>
+<dd>
+<pre><code><a href="cfish_Hash.html">cfish_Hash*</a> // incremented
+<strong>LUCY_DataWriter_Metadata</strong>(
+ lucy_DataWriter* <strong>self</strong>
+);
+</code></pre>
+<p>Arbitrary metadata to be serialized and stored by the Segment. The
+default implementation supplies a Hash with a single key-value pair for
+"format".</p>
+</dd>
+<dt>Format</dt>
+<dd>
+<pre><code>int32_t
+<strong>LUCY_DataWriter_Format</strong>(
+ lucy_DataWriter* <strong>self</strong>
+);
+</code></pre>
+<p>Every writer must specify a file format revision number, which should
+increment each time the format changes. Responsibility for revision
+checking is left to the companion DataReader.</p>
+</dd>
+<dt>Get_Snapshot</dt>
+<dd>
+<pre><code><a href="lucy_Snapshot.html">lucy_Snapshot*</a>
+<strong>LUCY_DataWriter_Get_Snapshot</strong>(
+ lucy_DataWriter* <strong>self</strong>
+);
+</code></pre>
+<p>Accessor for "snapshot" member var.</p>
+</dd>
+<dt>Get_Segment</dt>
+<dd>
+<pre><code><a href="lucy_Segment.html">lucy_Segment*</a>
+<strong>LUCY_DataWriter_Get_Segment</strong>(
+ lucy_DataWriter* <strong>self</strong>
+);
+</code></pre>
+<p>Accessor for "segment" member var.</p>
+</dd>
+<dt>Get_PolyReader</dt>
+<dd>
+<pre><code><a href="lucy_PolyReader.html">lucy_PolyReader*</a>
+<strong>LUCY_DataWriter_Get_PolyReader</strong>(
+ lucy_DataWriter* <strong>self</strong>
+);
+</code></pre>
+<p>Accessor for "polyreader" member var.</p>
+</dd>
+<dt>Get_Schema</dt>
+<dd>
+<pre><code><a href="lucy_Schema.html">lucy_Schema*</a>
+<strong>LUCY_DataWriter_Get_Schema</strong>(
+ lucy_DataWriter* <strong>self</strong>
+);
+</code></pre>
+<p>Accessor for "schema" member var.</p>
+</dd>
+<dt>Get_Folder</dt>
+<dd>
+<pre><code><a href="lucy_Folder.html">lucy_Folder*</a>
+<strong>LUCY_DataWriter_Get_Folder</strong>(
+ lucy_DataWriter* <strong>self</strong>
+);
+</code></pre>
+<p>Accessor for "folder" member var.</p>
+</dd>
+</dl>
+<h2>Inheritance</h2>
+<p>Lucy::Index::SegWriter is a <a href="lucy_DataWriter.html">Lucy::Index::DataWriter</a> is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p>
+</body>
+</html>
Added: lucy/site/trunk/content/docs/c/lucy_Segment.html
URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/lucy_Segment.html?rev=1641230&view=auto
==============================================================================
--- lucy/site/trunk/content/docs/c/lucy_Segment.html (added)
+++ lucy/site/trunk/content/docs/c/lucy_Segment.html Sun Nov 23 17:42:57 2014
@@ -0,0 +1,193 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta name="viewport" content="width=device-width" />
+<style type="text/css">
+body {
+ font-family: sans-serif;
+ font-size: 0.85em;
+ max-width: 640px;
+}
+dt {
+ font-weight: bold;
+}
+pre {
+ border: 1px solid #000;
+ padding: 0.2em 0.4em;
+ background: #f6f6f6;
+ font-size: 1.2em;
+}
+code {
+ font-family: "Consolas", "Menlo", monospace;
+}
+</style>
+</head>
+<body>
+<h1>Lucy::Index::Segment</h1>
+<h2>Name</h2>
+<p>Lucy::Index::Segment - Warehouse for information about one segment of an inverted index.</p>
+<h2>Description</h2>
+<p>Apache Lucy's indexes are made up of individual "segments", each of which is
+is an independent inverted index. On the file system, each segment is a
+directory within the main index directory whose name starts with "seg_":
+"seg_2", "seg_5a", etc.</p>
+<p>Each Segment object keeps track of information about an index segment: its
+fields, document count, and so on. The Segment object itself writes one
+file, <code>segmeta.json</code>; besides storing info needed by Segment
+itself, the "segmeta" file serves as a central repository for metadata
+generated by other index components -- relieving them of the burden of
+storing metadata themselves.</p>
+<h2>Functions</h2>
+<dl>
+<dt>init</dt>
+<dd>
+<pre><code>lucy_Segment*
+<strong>lucy_Seg_init</strong>(
+ lucy_Segment* <strong>self</strong>,
+ int64_t <strong>number</strong>
+);
+</code></pre>
+</dd>
+</dl>
+<h2>Methods</h2>
+<h3>Novel methods</h3>
+<dl>
+<dt>Add_Field</dt>
+<dd>
+<pre><code>int32_t
+<strong>LUCY_Seg_Add_Field</strong>(
+ lucy_Segment* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>field</strong>
+);
+</code></pre>
+<p>Register a new field and assign it a field number. If the field was
+already known, nothing happens.</p>
+<dl>
+<dt><emph>field</emph></dt>
+<dd><p>Field name.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> the field's field number, which is a positive integer.</p>
+</dd>
+<dt>Store_Metadata</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_Seg_Store_Metadata</strong>(
+ lucy_Segment* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>key</strong>,
+ <a href="cfish_Obj.html">cfish_Obj*</a> <strong>metadata</strong> // decremented
+);
+</code></pre>
+<p>Store arbitrary information in the segment's metadata Hash, to be
+serialized later. Throws an error if <code>key</code> is used twice.</p>
+<dl>
+<dt><emph>key</emph></dt>
+<dd><p>String identifying an index component.</p>
+</dd>
+<dt><emph>metadata</emph></dt>
+<dd><p>JSON-izable data structure.</p>
+</dd>
+</dl>
+</dd>
+<dt>Fetch_Metadata</dt>
+<dd>
+<pre><code><a href="cfish_Obj.html">cfish_Obj*</a>
+<strong>LUCY_Seg_Fetch_Metadata</strong>(
+ lucy_Segment* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>key</strong>
+);
+</code></pre>
+<p>Fetch a value from the Segment's metadata hash.</p>
+</dd>
+<dt>Field_Num</dt>
+<dd>
+<pre><code>int32_t
+<strong>LUCY_Seg_Field_Num</strong>(
+ lucy_Segment* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>field</strong>
+);
+</code></pre>
+<p>Given a field name, return its field number for this segment (which
+may differ from its number in other segments). Return 0 (an invalid
+field number) if the field name can't be found.</p>
+<dl>
+<dt><emph>field</emph></dt>
+<dd><p>Field name.</p>
+</dd>
+</dl>
+</dd>
+<dt>Field_Name</dt>
+<dd>
+<pre><code><a href="cfish_String.html">cfish_String*</a>
+<strong>LUCY_Seg_Field_Name</strong>(
+ lucy_Segment* <strong>self</strong>,
+ int32_t <strong>field_num</strong>
+);
+</code></pre>
+<p>Given a field number, return the name of its field, or NULL if the
+field name can't be found.</p>
+</dd>
+<dt>Get_Name</dt>
+<dd>
+<pre><code><a href="cfish_String.html">cfish_String*</a>
+<strong>LUCY_Seg_Get_Name</strong>(
+ lucy_Segment* <strong>self</strong>
+);
+</code></pre>
+<p>Getter for the object's seg name.</p>
+</dd>
+<dt>Get_Number</dt>
+<dd>
+<pre><code>int64_t
+<strong>LUCY_Seg_Get_Number</strong>(
+ lucy_Segment* <strong>self</strong>
+);
+</code></pre>
+<p>Getter for the segment number.</p>
+</dd>
+<dt>Set_Count</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_Seg_Set_Count</strong>(
+ lucy_Segment* <strong>self</strong>,
+ int64_t <strong>count</strong>
+);
+</code></pre>
+<p>Setter for the object's document count.</p>
+</dd>
+<dt>Get_Count</dt>
+<dd>
+<pre><code>int64_t
+<strong>LUCY_Seg_Get_Count</strong>(
+ lucy_Segment* <strong>self</strong>
+);
+</code></pre>
+<p>Getter for the object's document count.</p>
+</dd>
+<dt>Write_File</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_Seg_Write_File</strong>(
+ lucy_Segment* <strong>self</strong>,
+ <a href="lucy_Folder.html">lucy_Folder*</a> <strong>folder</strong>
+);
+</code></pre>
+<p>Write the segdata file.</p>
+</dd>
+<dt>Read_File</dt>
+<dd>
+<pre><code>bool
+<strong>LUCY_Seg_Read_File</strong>(
+ lucy_Segment* <strong>self</strong>,
+ <a href="lucy_Folder.html">lucy_Folder*</a> <strong>folder</strong>
+);
+</code></pre>
+<p>Read the segmeta file for this segment.</p>
+<p><strong>Returns:</strong> true if the file is read and decoded successfully, false
+otherwise.</p>
+</dd>
+</dl>
+<h2>Inheritance</h2>
+<p>Lucy::Index::Segment is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p>
+</body>
+</html>
Added: lucy/site/trunk/content/docs/c/lucy_Similarity.html
URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/lucy_Similarity.html?rev=1641230&view=auto
==============================================================================
--- lucy/site/trunk/content/docs/c/lucy_Similarity.html (added)
+++ lucy/site/trunk/content/docs/c/lucy_Similarity.html Sun Nov 23 17:42:57 2014
@@ -0,0 +1,180 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta name="viewport" content="width=device-width" />
+<style type="text/css">
+body {
+ font-family: sans-serif;
+ font-size: 0.85em;
+ max-width: 640px;
+}
+dt {
+ font-weight: bold;
+}
+pre {
+ border: 1px solid #000;
+ padding: 0.2em 0.4em;
+ background: #f6f6f6;
+ font-size: 1.2em;
+}
+code {
+ font-family: "Consolas", "Menlo", monospace;
+}
+</style>
+</head>
+<body>
+<h1>Lucy::Index::Similarity</h1>
+<h2>Name</h2>
+<p>Lucy::Index::Similarity - Judge how well a document matches a query.</p>
+<h2>Description</h2>
+<p>After determining whether a document matches a given query, a score must be
+calculated which indicates how <em>well</em> the document matches the query. The
+Similarity class is used to judge how "similar" the query and the document
+are to each other; the closer the resemblance, they higher the document
+scores.</p>
+<p>The default implementation uses Lucene's modified cosine similarity
+measure. Subclasses might tweak the existing algorithms, or might be used
+in conjunction with custom Query subclasses to implement arbitrary scoring
+schemes.</p>
+<p>Most of the methods operate on single fields, but some are used to combine
+scores from multiple fields.</p>
+<h2>Functions</h2>
+<dl>
+<dt>init</dt>
+<dd>
+<pre><code>lucy_Similarity*
+<strong>lucy_Sim_init</strong>(
+ lucy_Similarity* <strong>self</strong>
+);
+</code></pre>
+<p>Constructor. Takes no arguments.</p>
+</dd>
+</dl>
+<h2>Methods</h2>
+<h3>Novel methods</h3>
+<dl>
+<dt>Make_Posting</dt>
+<dd>
+<pre><code><a href="lucy_Posting.html">lucy_Posting*</a> // incremented
+<strong>LUCY_Sim_Make_Posting</strong>(
+ lucy_Similarity* <strong>self</strong>
+);
+</code></pre>
+<p>Factory method for creating a Posting.</p>
+</dd>
+<dt>TF</dt>
+<dd>
+<pre><code>float
+<strong>LUCY_Sim_TF</strong>(
+ lucy_Similarity* <strong>self</strong>,
+ float <strong>freq</strong>
+);
+</code></pre>
+<p>Return a score factor based on the frequency of a term in a given
+document. The default implementation is sqrt(freq). Other
+implementations typically produce ascending scores with ascending
+freqs, since the more times a doc matches, the more relevant it is
+likely to be.</p>
+</dd>
+<dt>IDF</dt>
+<dd>
+<pre><code>float
+<strong>LUCY_Sim_IDF</strong>(
+ lucy_Similarity* <strong>self</strong>,
+ int64_t <strong>doc_freq</strong>,
+ int64_t <strong>total_docs</strong>
+);
+</code></pre>
+<p>Calculate the Inverse Document Frequecy for a term in a given
+collection.</p>
+<dl>
+<dt><emph>doc_freq</emph></dt>
+<dd><p>The number of documents that the term appears in.</p>
+</dd>
+<dt><emph>total_docs</emph></dt>
+<dd><p>The number of documents in the collection.</p>
+</dd>
+</dl>
+</dd>
+<dt>Coord</dt>
+<dd>
+<pre><code>float
+<strong>LUCY_Sim_Coord</strong>(
+ lucy_Similarity* <strong>self</strong>,
+ uint32_t <strong>overlap</strong>,
+ uint32_t <strong>max_overlap</strong>
+);
+</code></pre>
+<p>Calculate a score factor based on the number of terms which match.</p>
+</dd>
+<dt>Length_Norm</dt>
+<dd>
+<pre><code>float
+<strong>LUCY_Sim_Length_Norm</strong>(
+ lucy_Similarity* <strong>self</strong>,
+ uint32_t <strong>num_tokens</strong>
+);
+</code></pre>
+<p>Dampen the scores of long documents.</p>
+<p>After a field is broken up into terms at index-time, each term must be
+assigned a weight. One of the factors in calculating this weight is
+the number of tokens that the original field was broken into.</p>
+<p>Typically, we assume that the more tokens in a field, the less
+important any one of them is -- so that, e.g. 5 mentions of "Kafka" in
+a short article are given more heft than 5 mentions of "Kafka" in an
+entire book. The default implementation of length_norm expresses this
+using an inverted square root.</p>
+<p>However, the inverted square root has a tendency to reward very short
+fields highly, which isn't always appropriate for fields you expect to
+have a lot of tokens on average.</p>
+</dd>
+<dt>Query_Norm</dt>
+<dd>
+<pre><code>float
+<strong>LUCY_Sim_Query_Norm</strong>(
+ lucy_Similarity* <strong>self</strong>,
+ float <strong>sum_of_squared_weights</strong>
+);
+</code></pre>
+<p>Normalize a Query's weight so that it is comparable to other Queries.</p>
+</dd>
+<dt>Dump</dt>
+<dd>
+<pre><code><a href="cfish_Obj.html">cfish_Obj*</a> // incremented
+<strong>LUCY_Sim_Dump</strong>(
+ lucy_Similarity* <strong>self</strong>
+);
+</code></pre>
+</dd>
+<dt>Load</dt>
+<dd>
+<pre><code>lucy_Similarity* // incremented
+<strong>LUCY_Sim_Load</strong>(
+ lucy_Similarity* <strong>self</strong>,
+ <a href="cfish_Obj.html">cfish_Obj*</a> <strong>dump</strong>
+);
+</code></pre>
+</dd>
+<dt>Serialize</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_Sim_Serialize</strong>(
+ lucy_Similarity* <strong>self</strong>,
+ <a href="lucy_OutStream.html">lucy_OutStream*</a> <strong>outstream</strong>
+);
+</code></pre>
+</dd>
+<dt>Deserialize</dt>
+<dd>
+<pre><code>lucy_Similarity* // incremented
+<strong>LUCY_Sim_Deserialize</strong>(
+ lucy_Similarity* <strong>self</strong>, // decremented
+ <a href="lucy_InStream.html">lucy_InStream*</a> <strong>instream</strong>
+);
+</code></pre>
+</dd>
+</dl>
+<h2>Inheritance</h2>
+<p>Lucy::Index::Similarity is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p>
+</body>
+</html>
Added: lucy/site/trunk/content/docs/c/lucy_Snapshot.html
URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/lucy_Snapshot.html?rev=1641230&view=auto
==============================================================================
--- lucy/site/trunk/content/docs/c/lucy_Snapshot.html (added)
+++ lucy/site/trunk/content/docs/c/lucy_Snapshot.html Sun Nov 23 17:42:57 2014
@@ -0,0 +1,166 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta name="viewport" content="width=device-width" />
+<style type="text/css">
+body {
+ font-family: sans-serif;
+ font-size: 0.85em;
+ max-width: 640px;
+}
+dt {
+ font-weight: bold;
+}
+pre {
+ border: 1px solid #000;
+ padding: 0.2em 0.4em;
+ background: #f6f6f6;
+ font-size: 1.2em;
+}
+code {
+ font-family: "Consolas", "Menlo", monospace;
+}
+</style>
+</head>
+<body>
+<h1>Lucy::Index::Snapshot</h1>
+<h2>Name</h2>
+<p>Lucy::Index::Snapshot - Point-in-time index file list.</p>
+<h2>Description</h2>
+<p>A Snapshot is list of index files and folders. Because index files, once
+written, are never modified, a Snapshot defines a point-in-time view of the
+data in an index.</p>
+<p><a href="lucy_IndexReader.html">IndexReader</a> objects interpret the data
+associated with a single Snapshot.</p>
+<h2>Functions</h2>
+<dl>
+<dt>new</dt>
+<dd>
+<pre><code>lucy_Snapshot* // incremented
+<strong>lucy_Snapshot_new</strong>(void);
+</code></pre>
+</dd>
+<dt>init</dt>
+<dd>
+<pre><code>lucy_Snapshot*
+<strong>lucy_Snapshot_init</strong>(
+ lucy_Snapshot* <strong>self</strong>
+);
+</code></pre>
+<p>Constructor. Takes no arguments.</p>
+</dd>
+</dl>
+<h2>Methods</h2>
+<h3>Novel methods</h3>
+<dl>
+<dt>List</dt>
+<dd>
+<pre><code><a href="cfish_VArray.html">cfish_VArray*</a> // incremented
+<strong>LUCY_Snapshot_List</strong>(
+ lucy_Snapshot* <strong>self</strong>
+);
+</code></pre>
+<p>Return an array of all entries.</p>
+</dd>
+<dt>Num_Entries</dt>
+<dd>
+<pre><code>uint32_t
+<strong>LUCY_Snapshot_Num_Entries</strong>(
+ lucy_Snapshot* <strong>self</strong>
+);
+</code></pre>
+<p>Return the number of entries (including directories).</p>
+</dd>
+<dt>Add_Entry</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_Snapshot_Add_Entry</strong>(
+ lucy_Snapshot* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>entry</strong>
+);
+</code></pre>
+<p>Add a filepath to the snapshot.</p>
+</dd>
+<dt>Delete_Entry</dt>
+<dd>
+<pre><code>bool
+<strong>LUCY_Snapshot_Delete_Entry</strong>(
+ lucy_Snapshot* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>entry</strong>
+);
+</code></pre>
+<p>Delete a filepath from the snapshot.</p>
+<p><strong>Returns:</strong> true if the entry existed and was successfully deleted, false
+otherwise.</p>
+</dd>
+<dt>Read_File</dt>
+<dd>
+<pre><code>lucy_Snapshot*
+<strong>LUCY_Snapshot_Read_File</strong>(
+ lucy_Snapshot* <strong>self</strong>,
+ <a href="lucy_Folder.html">lucy_Folder*</a> <strong>folder</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>path</strong>
+);
+</code></pre>
+<p>Decode a snapshot file and initialize the object to reflect its
+contents.</p>
+<dl>
+<dt><emph>folder</emph></dt>
+<dd><p>A Folder.</p>
+</dd>
+<dt><emph>path</emph></dt>
+<dd><p>The location of the snapshot file. If not supplied, the
+most recent snapshot file in the base directory will be chosen.</p>
+</dd>
+</dl>
+<p><strong>Returns:</strong> the object, allowing an assignment idiom.</p>
+</dd>
+<dt>Write_File</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_Snapshot_Write_File</strong>(
+ lucy_Snapshot* <strong>self</strong>,
+ <a href="lucy_Folder.html">lucy_Folder*</a> <strong>folder</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>path</strong>
+);
+</code></pre>
+<p>Write a snapshot file. The caller must lock the index while this
+operation takes place, and the operation will fail if the snapshot file
+already exists.</p>
+<dl>
+<dt><emph>folder</emph></dt>
+<dd><p>A Folder.</p>
+</dd>
+<dt><emph>path</emph></dt>
+<dd><p>The path of the file to write. If NULL, a file name will
+be chosen which supersedes the latest snapshot file in the index
+folder.</p>
+</dd>
+</dl>
+</dd>
+<dt>Set_Path</dt>
+<dd>
+<pre><code>void
+<strong>LUCY_Snapshot_Set_Path</strong>(
+ lucy_Snapshot* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>path</strong>
+);
+</code></pre>
+<p>Set the path to the file that the Snapshot object serves as a proxy
+for.</p>
+</dd>
+<dt>Get_Path</dt>
+<dd>
+<pre><code><a href="cfish_String.html">cfish_String*</a>
+<strong>LUCY_Snapshot_Get_Path</strong>(
+ lucy_Snapshot* <strong>self</strong>
+);
+</code></pre>
+<p>Get the path to the snapshot file. Initially NULL; updated by
+Read_File(), Write_File(), and Set_Path().</p>
+</dd>
+</dl>
+<h2>Inheritance</h2>
+<p>Lucy::Index::Snapshot is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p>
+</body>
+</html>
Added: lucy/site/trunk/content/docs/c/lucy_SnowballStemmer.html
URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/lucy_SnowballStemmer.html?rev=1641230&view=auto
==============================================================================
--- lucy/site/trunk/content/docs/c/lucy_SnowballStemmer.html (added)
+++ lucy/site/trunk/content/docs/c/lucy_SnowballStemmer.html Sun Nov 23 17:42:57 2014
@@ -0,0 +1,111 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta name="viewport" content="width=device-width" />
+<style type="text/css">
+body {
+ font-family: sans-serif;
+ font-size: 0.85em;
+ max-width: 640px;
+}
+dt {
+ font-weight: bold;
+}
+pre {
+ border: 1px solid #000;
+ padding: 0.2em 0.4em;
+ background: #f6f6f6;
+ font-size: 1.2em;
+}
+code {
+ font-family: "Consolas", "Menlo", monospace;
+}
+</style>
+</head>
+<body>
+<h1>Lucy::Analysis::SnowballStemmer</h1>
+<h2>Name</h2>
+<p>Lucy::Analysis::SnowballStemmer - Reduce related words to a shared root.</p>
+<h2>Description</h2>
+<p>SnowballStemmer is an <a href="lucy_Analyzer.html">Analyzer</a> which reduces
+related words to a root form (using the "Snowball" stemming library). For
+instance, "horse", "horses", and "horsing" all become "hors" -- so that a
+search for 'horse' will also match documents containing 'horses' and
+'horsing'.</p>
+<h2>Functions</h2>
+<dl>
+<dt>init</dt>
+<dd>
+<pre><code>lucy_SnowballStemmer*
+<strong>lucy_SnowStemmer_init</strong>(
+ lucy_SnowballStemmer* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>language</strong>
+);
+</code></pre>
+<dl>
+<dt><emph>language</emph></dt>
+<dd><p>A two-letter ISO code identifying a language supported
+by Snowball.</p>
+</dd>
+</dl>
+</dd>
+</dl>
+<h2>Methods</h2>
+<h3>Methods inherited from Lucy::Analysis::Analyzer</h3><dl>
+<dt>Transform</dt>
+<dd>
+<pre><code><a href="lucy_Inversion.html">lucy_Inversion*</a> // incremented
+<strong>LUCY_Analyzer_Transform</strong>(
+ lucy_Analyzer* <strong>self</strong>,
+ <a href="lucy_Inversion.html">lucy_Inversion*</a> <strong>inversion</strong>
+);
+</code></pre>
+<p>Take a single <a href="lucy_Inversion.html">Inversion</a> as input
+and returns an Inversion, either the same one (presumably transformed
+in some way), or a new one.</p>
+</dd>
+<dt>Transform_Text</dt>
+<dd>
+<pre><code><a href="lucy_Inversion.html">lucy_Inversion*</a> // incremented
+<strong>LUCY_Analyzer_Transform_Text</strong>(
+ lucy_Analyzer* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>text</strong>
+);
+</code></pre>
+<p>Kick off an analysis chain, creating an Inversion from string input.
+The default implementation simply creates an initial Inversion with a
+single Token, then calls Transform(), but occasionally subclasses will
+provide an optimized implementation which minimizes string copies.</p>
+</dd>
+<dt>Split</dt>
+<dd>
+<pre><code><a href="cfish_VArray.html">cfish_VArray*</a> // incremented
+<strong>LUCY_Analyzer_Split</strong>(
+ lucy_Analyzer* <strong>self</strong>,
+ <a href="cfish_String.html">cfish_String*</a> <strong>text</strong>
+);
+</code></pre>
+<p>Analyze text and return an array of token texts.</p>
+</dd>
+<dt>Dump</dt>
+<dd>
+<pre><code><a href="cfish_Obj.html">cfish_Obj*</a> // incremented
+<strong>LUCY_Analyzer_Dump</strong>(
+ lucy_Analyzer* <strong>self</strong>
+);
+</code></pre>
+</dd>
+<dt>Load</dt>
+<dd>
+<pre><code><a href="cfish_Obj.html">cfish_Obj*</a> // incremented
+<strong>LUCY_Analyzer_Load</strong>(
+ lucy_Analyzer* <strong>self</strong>,
+ <a href="cfish_Obj.html">cfish_Obj*</a> <strong>dump</strong>
+);
+</code></pre>
+</dd>
+</dl>
+<h2>Inheritance</h2>
+<p>Lucy::Analysis::SnowballStemmer is a <a href="lucy_Analyzer.html">Lucy::Analysis::Analyzer</a> is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p>
+</body>
+</html>