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>
