Added: websites/staging/lucy/trunk/content/docs/c/lucy_Lexicon.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_Lexicon.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_Lexicon.html Sun Nov 23 17:43:07 2014 @@ -0,0 +1,122 @@ +<!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::Lexicon</h1> +<h2>Name</h2> +<p>Lucy::Index::Lexicon - Iterator for a field's terms.</p> +<h2>Description</h2> +<p>A Lexicon is an iterator which provides access to all the unique terms for +a given field in sorted order.</p> +<p>If an index consists of two documents with a 'content' field holding "three +blind mice" and "three musketeers" respectively, then iterating through the +'content' field's lexicon would produce this list:</p> +<pre><code>blind +mice +musketeers +three +</code></pre> +<h2>Functions</h2> +<dl> +<dt>init</dt> +<dd> +<pre><code>lucy_Lexicon* +<strong>lucy_Lex_init</strong>( + lucy_Lexicon* <strong>self</strong>, + <a href="cfish_String.html">cfish_String*</a> <strong>field</strong> +); +</code></pre> +</dd> +</dl> +<h2>Methods</h2> +<h3>Abstract methods</h3> +<dl> +<dt>Seek</dt> +<dd> +<pre><code>void +<strong>LUCY_Lex_Seek</strong>( + lucy_Lexicon* <strong>self</strong>, + <a href="cfish_Obj.html">cfish_Obj*</a> <strong>target</strong> +); +</code></pre> +<p>Seek the Lexicon to the first iterator state which is greater than or +equal to <code>target</code>. If <code>target</code> is NULL, +reset the iterator.</p> +</dd> +<dt>Next</dt> +<dd> +<pre><code>bool +<strong>LUCY_Lex_Next</strong>( + lucy_Lexicon* <strong>self</strong> +); +</code></pre> +<p>Proceed to the next term.</p> +<p><strong>Returns:</strong> true until the iterator is exhausted, then false.</p> +</dd> +<dt>Reset</dt> +<dd> +<pre><code>void +<strong>LUCY_Lex_Reset</strong>( + lucy_Lexicon* <strong>self</strong> +); +</code></pre> +<p>Reset the iterator. Next() must be called to proceed to the first +element.</p> +</dd> +<dt>Doc_Freq</dt> +<dd> +<pre><code>int32_t +<strong>LUCY_Lex_Doc_Freq</strong>( + lucy_Lexicon* <strong>self</strong> +); +</code></pre> +<p>Return the number of documents that the current term appears in at +least once. Deleted documents may be included in the count.</p> +</dd> +<dt>Get_Term</dt> +<dd> +<pre><code><a href="cfish_Obj.html">cfish_Obj*</a> +<strong>LUCY_Lex_Get_Term</strong>( + lucy_Lexicon* <strong>self</strong> +); +</code></pre> +<p>Return the current term, or NULL if the iterator is not in a valid +state.</p> +</dd> +</dl> +<h3>Novel methods</h3> +<dl> +<dt>Get_Field</dt> +<dd> +<pre><code><a href="cfish_String.html">cfish_String*</a> +<strong>LUCY_Lex_Get_Field</strong>( + lucy_Lexicon* <strong>self</strong> +); +</code></pre> +</dd> +</dl> +<h2>Inheritance</h2> +<p>Lucy::Index::Lexicon is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p> +</body> +</html>
Added: websites/staging/lucy/trunk/content/docs/c/lucy_LexiconReader.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_LexiconReader.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_LexiconReader.html Sun Nov 23 17:43:07 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::Index::LexiconReader</h1> +<h2>Name</h2> +<p>Lucy::Index::LexiconReader - Read Lexicon data.</p> +<h2>Description</h2> +<p>LexiconReader reads term dictionary information.</p> +<h2>Methods</h2> +<h3>Abstract methods</h3> +<dl> +<dt>Lexicon</dt> +<dd> +<pre><code><a href="lucy_Lexicon.html">lucy_Lexicon*</a> // incremented +<strong>LUCY_LexReader_Lexicon</strong>( + lucy_LexiconReader* <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 a new Lexicon for the given <code>field</code>. Will return +NULL if either the field is not indexed, or if no documents contain a +value for the field.</p> +<dl> +<dt><emph>field</emph></dt> +<dd><p>Field name.</p> +</dd> +<dt><emph>term</emph></dt> +<dd><p>Pre-locate the Lexicon to this term.</p> +</dd> +</dl> +</dd> +<dt>Doc_Freq</dt> +<dd> +<pre><code>uint32_t +<strong>LUCY_LexReader_Doc_Freq</strong>( + lucy_LexiconReader* <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 where the specified term is present.</p> +</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::LexiconReader 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: websites/staging/lucy/trunk/content/docs/c/lucy_Lock.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_Lock.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_Lock.html Sun Nov 23 17:43:07 2014 @@ -0,0 +1,148 @@ +<!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::Lock</h1> +<h2>Name</h2> +<p>Lucy::Store::Lock - Abstract class representing an interprocess mutex lock.</p> +<h2>Description</h2> +<p>The Lock class produces an interprocess mutex lock. The default subclass +uses dot-lock files, but alternative implementations are possible.</p> +<p>Each lock must have a name which is unique per resource to be locked. Each +lock also has a "host" id which should be unique per machine; it is used to +help clear away stale locks.</p> +<h2>Functions</h2> +<dl> +<dt>init</dt> +<dd> +<pre><code>lucy_Lock* +<strong>lucy_Lock_init</strong>( + lucy_Lock* <strong>self</strong>, + <a href="lucy_Folder.html">lucy_Folder*</a> <strong>folder</strong>, + <a href="cfish_String.html">cfish_String*</a> <strong>name</strong>, + <a href="cfish_String.html">cfish_String*</a> <strong>host</strong>, + int32_t <strong>timeout</strong>, + int32_t <strong>interval</strong> +); +</code></pre> +<p>Abstract constructor.</p> +<dl> +<dt><emph>folder</emph></dt> +<dd><p>A Folder.</p> +</dd> +<dt><emph>name</emph></dt> +<dd><p>String identifying the resource to be locked, which must +consist solely of characters matching [-_.A-Za-z0-9].</p> +</dd> +<dt><emph>host</emph></dt> +<dd><p>A unique per-machine identifier.</p> +</dd> +<dt><emph>timeout</emph></dt> +<dd><p>Time in milliseconds to keep retrying before abandoning +the attempt to Obtain() a lock.</p> +</dd> +<dt><emph>interval</emph></dt> +<dd><p>Time in milliseconds between retries.</p> +</dd> +</dl> +</dd> +</dl> +<h2>Methods</h2> +<h3>Abstract methods</h3> +<dl> +<dt>Shared</dt> +<dd> +<pre><code>bool +<strong>LUCY_Lock_Shared</strong>( + lucy_Lock* <strong>self</strong> +); +</code></pre> +<p>Returns true if the Lock is shared, false if the Lock is exclusive.</p> +</dd> +<dt>Request</dt> +<dd> +<pre><code>bool +<strong>LUCY_Lock_Request</strong>( + lucy_Lock* <strong>self</strong> +); +</code></pre> +<p>Make one attempt to acquire the lock.</p> +<p>The semantics of Request() differ depending on whether Shared() returns +true. If the Lock is Shared(), then Request() should not fail if +another lock is held against the resource identified by +<code>name</code> (though it might fail for other reasons). If it is +not Shared() -- i.e. it's an exclusive (write) lock -- then other locks +should cause Request() to fail.</p> +<p><strong>Returns:</strong> true on success, false on failure (sets Err_error).</p> +</dd> +<dt>Release</dt> +<dd> +<pre><code>void +<strong>LUCY_Lock_Release</strong>( + lucy_Lock* <strong>self</strong> +); +</code></pre> +<p>Release the lock.</p> +</dd> +<dt>Is_Locked</dt> +<dd> +<pre><code>bool +<strong>LUCY_Lock_Is_Locked</strong>( + lucy_Lock* <strong>self</strong> +); +</code></pre> +<p>Indicate whether the resource identified by this lock's name is +currently locked.</p> +<p><strong>Returns:</strong> true if the resource is locked, false otherwise.</p> +</dd> +<dt>Clear_Stale</dt> +<dd> +<pre><code>void +<strong>LUCY_Lock_Clear_Stale</strong>( + lucy_Lock* <strong>self</strong> +); +</code></pre> +<p>Release all locks that meet the following three conditions: the lock +name matches, the host id matches, and the process id that the lock +was created under no longer identifies an active process.</p> +</dd> +</dl> +<h3>Novel methods</h3> +<dl> +<dt>Obtain</dt> +<dd> +<pre><code>bool +<strong>LUCY_Lock_Obtain</strong>( + lucy_Lock* <strong>self</strong> +); +</code></pre> +<p>Call Request() once per <code>interval</code> until Request() returns +success or the <code>timeout</code> has been reached.</p> +<p><strong>Returns:</strong> true on success, false on failure (sets Err_error).</p> +</dd> +</dl> +<h2>Inheritance</h2> +<p>Lucy::Store::Lock is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p> +</body> +</html> Added: websites/staging/lucy/trunk/content/docs/c/lucy_LockErr.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_LockErr.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_LockErr.html Sun Nov 23 17:43:07 2014 @@ -0,0 +1,76 @@ +<!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::LockErr</h1> +<h2>Name</h2> +<p>Lucy::Store::LockErr - Lock exception.</p> +<h2>Description</h2> +<p>LockErr is a subclass of <a href="cfish_Err.html">Err</a> which indicates +that a file locking problem occurred.</p> +<h2>Functions</h2> +<dl> +<dt>new</dt> +<dd> +<pre><code>lucy_LockErr* // incremented +<strong>lucy_LockErr_new</strong>( + <a href="cfish_String.html">cfish_String*</a> <strong>message</strong> +); +</code></pre> +</dd> +<dt>init</dt> +<dd> +<pre><code>lucy_LockErr* +<strong>lucy_LockErr_init</strong>( + lucy_LockErr* <strong>self</strong>, + <a href="cfish_String.html">cfish_String*</a> <strong>message</strong> +); +</code></pre> +</dd> +</dl> +<h2>Methods</h2> +<h3>Methods inherited from Clownfish::Err</h3><dl> +<dt>Cat_Mess</dt> +<dd> +<pre><code>void +<strong>CFISH_Err_Cat_Mess</strong>( + cfish_Err* <strong>self</strong>, + <a href="cfish_String.html">cfish_String*</a> <strong>mess</strong> +); +</code></pre> +<p>Concatenate the supplied argument onto the internal "mess".</p> +</dd> +<dt>Get_Mess</dt> +<dd> +<pre><code><a href="cfish_String.html">cfish_String*</a> +<strong>CFISH_Err_Get_Mess</strong>( + cfish_Err* <strong>self</strong> +); +</code></pre> +</dd> +</dl> +<h2>Inheritance</h2> +<p>Lucy::Store::LockErr is a <a href="cfish_Err.html">Clownfish::Err</a> is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p> +</body> +</html> Added: websites/staging/lucy/trunk/content/docs/c/lucy_LockFactory.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_LockFactory.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_LockFactory.html Sun Nov 23 17:43:07 2014 @@ -0,0 +1,115 @@ +<!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::LockFactory</h1> +<h2>Name</h2> +<p>Lucy::Store::LockFactory - Create Locks.</p> +<h2>Description</h2> +<p>LockFactory is used to spin off interprocess mutex locks used by various +index reading and writing components. The default implementation uses +lockfiles, but LockFactory subclasses which are implemented using +alternatives such as flock() are possible.</p> +<h2>Functions</h2> +<dl> +<dt>init</dt> +<dd> +<pre><code>lucy_LockFactory* +<strong>lucy_LockFact_init</strong>( + lucy_LockFactory* <strong>self</strong>, + <a href="lucy_Folder.html">lucy_Folder*</a> <strong>folder</strong>, + <a href="cfish_String.html">cfish_String*</a> <strong>host</strong> +); +</code></pre> +<dl> +<dt><emph>folder</emph></dt> +<dd><p>A <a href="lucy_Folder.html">Folder</a>.</p> +</dd> +<dt><emph>host</emph></dt> +<dd><p>An identifier which should be unique per-machine.</p> +</dd> +</dl> +</dd> +</dl> +<h2>Methods</h2> +<h3>Novel methods</h3> +<dl> +<dt>Make_Lock</dt> +<dd> +<pre><code><a href="lucy_Lock.html">lucy_Lock*</a> // incremented +<strong>LUCY_LockFact_Make_Lock</strong>( + lucy_LockFactory* <strong>self</strong>, + <a href="cfish_String.html">cfish_String*</a> <strong>name</strong>, + int32_t <strong>timeout</strong>, + int32_t <strong>interval</strong> +); +</code></pre> +<p>Return a Lock object, which, once Obtain() returns successfully, +maintains an exclusive lock on a resource.</p> +<dl> +<dt><emph>name</emph></dt> +<dd><p>A file-system-friendly id which identifies the +resource to be locked.</p> +</dd> +<dt><emph>timeout</emph></dt> +<dd><p>Time in milliseconds to keep retrying before abandoning +the attempt to Obtain() a lock.</p> +</dd> +<dt><emph>interval</emph></dt> +<dd><p>Time in milliseconds between retries.</p> +</dd> +</dl> +</dd> +<dt>Make_Shared_Lock</dt> +<dd> +<pre><code><a href="lucy_Lock.html">lucy_Lock*</a> // incremented +<strong>LUCY_LockFact_Make_Shared_Lock</strong>( + lucy_LockFactory* <strong>self</strong>, + <a href="cfish_String.html">cfish_String*</a> <strong>name</strong>, + int32_t <strong>timeout</strong>, + int32_t <strong>interval</strong> +); +</code></pre> +<p>Return a Lock object for which Shared() returns true, and which +maintains a non-exclusive lock on a resource once Obtain() returns +success.</p> +<dl> +<dt><emph>name</emph></dt> +<dd><p>A file-system-friendly id which identifies the +resource to be locked.</p> +</dd> +<dt><emph>timeout</emph></dt> +<dd><p>Time in milliseconds to keep retrying before abandoning +the attempt to Obtain() a lock.</p> +</dd> +<dt><emph>interval</emph></dt> +<dd><p>Time in milliseconds between retries.</p> +</dd> +</dl> +</dd> +</dl> +<h2>Inheritance</h2> +<p>Lucy::Store::LockFactory is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p> +</body> +</html> Added: websites/staging/lucy/trunk/content/docs/c/lucy_MatchAllQuery.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_MatchAllQuery.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_MatchAllQuery.html Sun Nov 23 17:43:07 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::Search::MatchAllQuery</h1> +<h2>Name</h2> +<p>Lucy::Search::MatchAllQuery - Query which matches all documents.</p> +<h2>Description</h2> +<p>MatchAllQuery is a utility class which matches all documents. Each match +is assigned a score of 0.0, so that in composite queries, any document +which matches against another part of the query will be ranked higher than +a document which matches only via the MatchAllQuery.</p> +<h2>Functions</h2> +<dl> +<dt>init</dt> +<dd> +<pre><code>lucy_MatchAllQuery* +<strong>lucy_MatchAllQuery_init</strong>( + lucy_MatchAllQuery* <strong>self</strong> +); +</code></pre> +<p>Constructor. Takes no arguments.</p> +</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::MatchAllQuery 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: websites/staging/lucy/trunk/content/docs/c/lucy_Matcher.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_Matcher.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_Matcher.html Sun Nov 23 17:43:07 2014 @@ -0,0 +1,105 @@ +<!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::Matcher</h1> +<h2>Name</h2> +<p>Lucy::Search::Matcher - Match a set of document ids.</p> +<h2>Description</h2> +<p>A Matcher iterates over a set of ascending document ids. Some Matchers +implement Score() and can assign relevance scores to the docs that they +match. Other implementations may be match-only.</p> +<h2>Functions</h2> +<dl> +<dt>init</dt> +<dd> +<pre><code>lucy_Matcher* +<strong>lucy_Matcher_init</strong>( + lucy_Matcher* <strong>self</strong> +); +</code></pre> +<p>Abstract constructor.</p> +</dd> +</dl> +<h2>Methods</h2> +<h3>Abstract methods</h3> +<dl> +<dt>Next</dt> +<dd> +<pre><code>int32_t +<strong>LUCY_Matcher_Next</strong>( + lucy_Matcher* <strong>self</strong> +); +</code></pre> +<p>Proceed to the next doc id.</p> +<p><strong>Returns:</strong> A positive doc id, or 0 once the iterator is exhausted.</p> +</dd> +<dt>Get_Doc_ID</dt> +<dd> +<pre><code>int32_t +<strong>LUCY_Matcher_Get_Doc_ID</strong>( + lucy_Matcher* <strong>self</strong> +); +</code></pre> +<p>Return the current doc id. Valid only after a successful call to +Next() or Advance() and must not be called otherwise.</p> +</dd> +<dt>Score</dt> +<dd> +<pre><code>float +<strong>LUCY_Matcher_Score</strong>( + lucy_Matcher* <strong>self</strong> +); +</code></pre> +<p>Return the score of the current document.</p> +<p>Only Matchers which are used for scored search need implement Score().</p> +</dd> +</dl> +<h3>Novel methods</h3> +<dl> +<dt>Advance</dt> +<dd> +<pre><code>int32_t +<strong>LUCY_Matcher_Advance</strong>( + lucy_Matcher* <strong>self</strong>, + int32_t <strong>target</strong> +); +</code></pre> +<p>Advance the iterator to the first doc id greater than or equal to +<code>target</code>. The default implementation simply calls Next() +over and over, but subclasses have the option of doing something more +efficient.</p> +<dl> +<dt><emph>target</emph></dt> +<dd><p>A positive doc id, which must be greater than the current +doc id once the iterator has been initialized.</p> +</dd> +</dl> +<p><strong>Returns:</strong> A positive doc id, or 0 once the iterator is exhausted.</p> +</dd> +</dl> +<h2>Inheritance</h2> +<p>Lucy::Search::Matcher is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p> +</body> +</html> Added: websites/staging/lucy/trunk/content/docs/c/lucy_NOTQuery.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_NOTQuery.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_NOTQuery.html Sun Nov 23 17:43:07 2014 @@ -0,0 +1,173 @@ +<!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::NOTQuery</h1> +<h2>Name</h2> +<p>Lucy::Search::NOTQuery - Invert the result set of another Query.</p> +<h2>Description</h2> +<p>A NOTQuery wraps another <a href="lucy_Query.html">Query</a> and matches +against its inverse document set. All matching docs recieve a score of +0.0.</p> +<p>NOTQuery is often used in conjunction with +<a href="lucy_ANDQuery.html">ANDQuery</a> to provide "a AND NOT b" +semantics.</p> +<h2>Functions</h2> +<dl> +<dt>init</dt> +<dd> +<pre><code>lucy_NOTQuery* +<strong>lucy_NOTQuery_init</strong>( + lucy_NOTQuery* <strong>self</strong>, + <a href="lucy_Query.html">lucy_Query*</a> <strong>negated_query</strong> +); +</code></pre> +<dl> +<dt><emph>negated_query</emph></dt> +<dd><p>The Query whose result set should be inverted.</p> +</dd> +</dl> +</dd> +</dl> +<h2>Methods</h2> +<h3>Novel methods</h3> +<dl> +<dt>Get_Negated_Query</dt> +<dd> +<pre><code><a href="lucy_Query.html">lucy_Query*</a> +<strong>LUCY_NOTQuery_Get_Negated_Query</strong>( + lucy_NOTQuery* <strong>self</strong> +); +</code></pre> +<p>Accessor for the object's negated query.</p> +</dd> +<dt>Set_Negated_Query</dt> +<dd> +<pre><code>void +<strong>LUCY_NOTQuery_Set_Negated_Query</strong>( + lucy_NOTQuery* <strong>self</strong>, + <a href="lucy_Query.html">lucy_Query*</a> <strong>negated_query</strong> +); +</code></pre> +<p>Setter for the object's negated 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::NOTQuery 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: websites/staging/lucy/trunk/content/docs/c/lucy_NoMatchQuery.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_NoMatchQuery.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_NoMatchQuery.html Sun Nov 23 17:43:07 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::Search::NoMatchQuery</h1> +<h2>Name</h2> +<p>Lucy::Search::NoMatchQuery - Query which matches no documents.</p> +<h2>Description</h2> +<p>NoMatchQuery is a utility class representing a query which matches nothing. +Typical usage might include e.g. returning a NoMatchQuery when a +<a href="lucy_QueryParser.html">QueryParser</a> is asked to parse an empty +string.</p> +<h2>Functions</h2> +<dl> +<dt>init</dt> +<dd> +<pre><code>lucy_NoMatchQuery* +<strong>lucy_NoMatchQuery_init</strong>( + lucy_NoMatchQuery* <strong>self</strong> +); +</code></pre> +<p>Constructor. Takes no arguments.</p> +</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::NoMatchQuery 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: websites/staging/lucy/trunk/content/docs/c/lucy_Normalizer.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_Normalizer.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_Normalizer.html Sun Nov 23 17:43:07 2014 @@ -0,0 +1,120 @@ +<!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::Normalizer</h1> +<h2>Name</h2> +<p>Lucy::Analysis::Normalizer - Unicode normalization, case folding and accent stripping.</p> +<h2>Description</h2> +<p>Normalizer is an <a href="lucy_Analyzer.html">Analyzer</a> which normalizes +tokens to one of the Unicode normalization forms. Optionally, it +performs Unicode case folding and converts accented characters to their +base character.</p> +<p>If you use highlighting, Normalizer should be run after tokenization +because it might add or remove characters.</p> +<h2>Functions</h2> +<dl> +<dt>init</dt> +<dd> +<pre><code>lucy_Normalizer* +<strong>lucy_Normalizer_init</strong>( + lucy_Normalizer* <strong>self</strong>, + <a href="cfish_String.html">cfish_String*</a> <strong>normalization_form</strong>, + bool <strong>case_fold</strong>, + bool <strong>strip_accents</strong> +); +</code></pre> +<dl> +<dt><emph>normalization_form</emph></dt> +<dd><p>Unicode normalization form, can be one of +'NFC', 'NFKC', 'NFD', 'NFKD'. Defaults to 'NFKC'.</p> +</dd> +<dt><emph>case_fold</emph></dt> +<dd><p>Perform case folding, default is true.</p> +</dd> +<dt><emph>strip_accents</emph></dt> +<dd><p>Strip accents, default is false.</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::Normalizer 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: websites/staging/lucy/trunk/content/docs/c/lucy_ORQuery.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_ORQuery.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_ORQuery.html Sun Nov 23 17:43:07 2014 @@ -0,0 +1,149 @@ +<!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::ORQuery</h1> +<h2>Name</h2> +<p>Lucy::Search::ORQuery - Union multiple result sets.</p> +<h2>Description</h2> +<p>ORQuery is a composite <a href="lucy_Query.html">Query</a> which matches +when any of its children match, so its result set is the union of their +result sets. Matching documents recieve a summed score from all matching +child Queries.</p> +<h2>Functions</h2> +<dl> +<dt>init</dt> +<dd> +<pre><code>lucy_ORQuery* +<strong>lucy_ORQuery_init</strong>( + lucy_ORQuery* <strong>self</strong>, + <a href="cfish_VArray.html">cfish_VArray*</a> <strong>children</strong> +); +</code></pre> +<dl> +<dt><emph>children</emph></dt> +<dd><p>An array of child Queries.</p> +</dd> +</dl> +</dd> +</dl> +<h2>Methods</h2> +<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::ORQuery 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: websites/staging/lucy/trunk/content/docs/c/lucy_PhraseQuery.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_PhraseQuery.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_PhraseQuery.html Sun Nov 23 17:43:07 2014 @@ -0,0 +1,160 @@ +<!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::PhraseQuery</h1> +<h2>Name</h2> +<p>Lucy::Search::PhraseQuery - Query matching an ordered list of terms.</p> +<h2>Description</h2> +<p>PhraseQuery is a subclass of <a href="lucy_Query.html">Query</a> for matching +against an ordered sequence of terms.</p> +<h2>Functions</h2> +<dl> +<dt>init</dt> +<dd> +<pre><code>lucy_PhraseQuery* +<strong>lucy_PhraseQuery_init</strong>( + lucy_PhraseQuery* <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> +<dl> +<dt><emph>field</emph></dt> +<dd><p>The field that the phrase must occur in.</p> +</dd> +<dt><emph>terms</emph></dt> +<dd><p>The ordered array of terms that must match.</p> +</dd> +</dl> +</dd> +</dl> +<h2>Methods</h2> +<h3>Novel methods</h3> +<dl> +<dt>Get_Field</dt> +<dd> +<pre><code><a href="cfish_String.html">cfish_String*</a> +<strong>LUCY_PhraseQuery_Get_Field</strong>( + lucy_PhraseQuery* <strong>self</strong> +); +</code></pre> +<p>Accessor for object's field attribute.</p> +</dd> +<dt>Get_Terms</dt> +<dd> +<pre><code><a href="cfish_VArray.html">cfish_VArray*</a> +<strong>LUCY_PhraseQuery_Get_Terms</strong>( + lucy_PhraseQuery* <strong>self</strong> +); +</code></pre> +<p>Accessor for object's array of terms.</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::PhraseQuery 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: websites/staging/lucy/trunk/content/docs/c/lucy_PolyAnalyzer.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_PolyAnalyzer.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_PolyAnalyzer.html Sun Nov 23 17:43:07 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::Analysis::PolyAnalyzer</h1> +<h2>Name</h2> +<p>Lucy::Analysis::PolyAnalyzer - Multiple Analyzers in series.</p> +<h2>Description</h2> +<p>A PolyAnalyzer is a series of <a href="lucy_Analyzer.html">Analyzers</a>, +each of which will be called upon to "analyze" text in turn. You can +either provide the Analyzers yourself, or you can specify a supported +language, in which case a PolyAnalyzer consisting of a +<a href="lucy_CaseFolder.html">CaseFolder</a>, a +<a href="lucy_RegexTokenizer.html">RegexTokenizer</a>, and a +<a href="lucy_SnowballStemmer.html">SnowballStemmer</a> will be generated for you.</p> +<p>The language parameter is DEPRECATED. Use +<a href="lucy_EasyAnalyzer.html">EasyAnalyzer</a> instead.</p> +<p>Supported languages:</p> +<pre><code>en => English, +da => Danish, +de => German, +es => Spanish, +fi => Finnish, +fr => French, +hu => Hungarian, +it => Italian, +nl => Dutch, +no => Norwegian, +pt => Portuguese, +ro => Romanian, +ru => Russian, +sv => Swedish, +tr => Turkish, +</code></pre> +<h2>Functions</h2> +<dl> +<dt>init</dt> +<dd> +<pre><code>lucy_PolyAnalyzer* +<strong>lucy_PolyAnalyzer_init</strong>( + lucy_PolyAnalyzer* <strong>self</strong>, + <a href="cfish_String.html">cfish_String*</a> <strong>language</strong>, + <a href="cfish_VArray.html">cfish_VArray*</a> <strong>analyzers</strong> +); +</code></pre> +<dl> +<dt><emph>language</emph></dt> +<dd><p>An ISO code from the list of supported languages. +DEPRECATED, use <a href="lucy_EasyAnalyzer.html">EasyAnalyzer</a> instead.</p> +</dd> +<dt><emph>analyzers</emph></dt> +<dd><p>An array of Analyzers. The order of the analyzers +matters. Don't put a SnowballStemmer before a RegexTokenizer (can't stem whole +documents or paragraphs -- just individual words), or a SnowballStopFilter +after a SnowballStemmer (stemmed words, e.g. "themselv", will not appear in a +stoplist). In general, the sequence should be: tokenize, normalize, +stopalize, stem.</p> +</dd> +</dl> +</dd> +</dl> +<h2>Methods</h2> +<h3>Novel methods</h3> +<dl> +<dt>Get_Analyzers</dt> +<dd> +<pre><code><a href="cfish_VArray.html">cfish_VArray*</a> +<strong>LUCY_PolyAnalyzer_Get_Analyzers</strong>( + lucy_PolyAnalyzer* <strong>self</strong> +); +</code></pre> +<p>Getter for "analyzers" member.</p> +</dd> +</dl> +<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::PolyAnalyzer 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: websites/staging/lucy/trunk/content/docs/c/lucy_PolyQuery.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_PolyQuery.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_PolyQuery.html Sun Nov 23 17:43:07 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::PolyQuery</h1> +<h2>Name</h2> +<p>Lucy::Search::PolyQuery - Base class for composite Query objects.</p> +<h2>Description</h2> +<p>PolyQuery serves as a shared base class for +<a href="lucy_ANDQuery.html">ANDQuery</a>, +<a href="lucy_ORQuery.html">ORQuery</a>, +<a href="lucy_NOTQuery.html">NOTQuery</a>, and +<a href="lucy_RequiredOptionalQuery.html">RequiredOptionalQuery</a>. All of +these classes may serve as nodes in composite Query with a tree structure +which may be walked.</p> +<h2>Functions</h2> +<dl> +<dt>init</dt> +<dd> +<pre><code>lucy_PolyQuery* +<strong>lucy_PolyQuery_init</strong>( + lucy_PolyQuery* <strong>self</strong>, + <a href="cfish_VArray.html">cfish_VArray*</a> <strong>children</strong> +); +</code></pre> +<dl> +<dt><emph>children</emph></dt> +<dd><p>An array of child Queries.</p> +</dd> +</dl> +</dd> +</dl> +<h2>Methods</h2> +<h3>Novel methods</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::PolyQuery 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: websites/staging/lucy/trunk/content/docs/c/lucy_PolyReader.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_PolyReader.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_PolyReader.html Sun Nov 23 17:43:07 2014 @@ -0,0 +1,276 @@ +<!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::PolyReader</h1> +<h2>Name</h2> +<p>Lucy::Index::PolyReader - Multi-segment implementation of IndexReader.</p> +<h2>Description</h2> +<p>PolyReader conflates index data from multiple segments. For instance, if +an index contains three segments with 10 documents each, PolyReader's +Doc_Max() method will return 30.</p> +<p>Some of PolyReader's <a href="lucy_DataReader.html">DataReader</a> components +may be less efficient or complete than the single-segment implementations +accessed via <a href="lucy_SegReader.html">SegReader</a>.</p> +<h2>Functions</h2> +<dl> +<dt>open</dt> +<dd> +<pre><code>lucy_PolyReader* // incremented +<strong>lucy_PolyReader_open</strong>( + <a href="cfish_Obj.html">cfish_Obj*</a> <strong>index</strong>, + <a href="lucy_Snapshot.html">lucy_Snapshot*</a> <strong>snapshot</strong>, + <a href="lucy_IndexManager.html">lucy_IndexManager*</a> <strong>manager</strong> +); +</code></pre> +</dd> +<dt>do_open</dt> +<dd> +<pre><code>lucy_PolyReader* +<strong>lucy_PolyReader_do_open</strong>( + lucy_PolyReader* <strong>self</strong>, + <a href="cfish_Obj.html">cfish_Obj*</a> <strong>index</strong>, + <a href="lucy_Snapshot.html">lucy_Snapshot*</a> <strong>snapshot</strong>, + <a href="lucy_IndexManager.html">lucy_IndexManager*</a> <strong>manager</strong> +); +</code></pre> +<dl> +<dt><emph>index</emph></dt> +<dd><p>Either a string filepath or a <a href="lucy_Folder.html">Folder</a>.</p> +</dd> +<dt><emph>snapshot</emph></dt> +<dd><p>A Snapshot. If not supplied, the most recent snapshot +file will be used.</p> +</dd> +<dt><emph>manager</emph></dt> +<dd><p>An <a href="lucy_IndexManager.html">IndexManager</a>. +Read-locking is off by default; supplying this argument turns it on.</p> +</dd> +</dl> +</dd> +<dt>new</dt> +<dd> +<pre><code>lucy_PolyReader* // incremented +<strong>lucy_PolyReader_new</strong>( + <a href="lucy_Schema.html">lucy_Schema*</a> <strong>schema</strong>, + <a href="lucy_Folder.html">lucy_Folder*</a> <strong>folder</strong>, + <a href="lucy_Snapshot.html">lucy_Snapshot*</a> <strong>snapshot</strong>, + <a href="lucy_IndexManager.html">lucy_IndexManager*</a> <strong>manager</strong>, + <a href="cfish_VArray.html">cfish_VArray*</a> <strong>sub_readers</strong> +); +</code></pre> +</dd> +<dt>init</dt> +<dd> +<pre><code>lucy_PolyReader* +<strong>lucy_PolyReader_init</strong>( + lucy_PolyReader* <strong>self</strong>, + <a href="lucy_Schema.html">lucy_Schema*</a> <strong>schema</strong>, + <a href="lucy_Folder.html">lucy_Folder*</a> <strong>folder</strong>, + <a href="lucy_Snapshot.html">lucy_Snapshot*</a> <strong>snapshot</strong>, + <a href="lucy_IndexManager.html">lucy_IndexManager*</a> <strong>manager</strong>, + <a href="cfish_VArray.html">cfish_VArray*</a> <strong>sub_readers</strong> +); +</code></pre> +</dd> +</dl> +<h2>Methods</h2> +<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::PolyReader 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: websites/staging/lucy/trunk/content/docs/c/lucy_PolySearcher.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_PolySearcher.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_PolySearcher.html Sun Nov 23 17:43:07 2014 @@ -0,0 +1,179 @@ +<!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::PolySearcher</h1> +<h2>Name</h2> +<p>Lucy::Search::PolySearcher - Aggregate results from multiple Searchers.</p> +<h2>Description</h2> +<p>The primary use for PolySearcher is to aggregate results from several +indexes on a single machine.</p> +<h2>Functions</h2> +<dl> +<dt>init</dt> +<dd> +<pre><code>lucy_PolySearcher* +<strong>lucy_PolySearcher_init</strong>( + lucy_PolySearcher* <strong>self</strong>, + <a href="lucy_Schema.html">lucy_Schema*</a> <strong>schema</strong>, + <a href="cfish_VArray.html">cfish_VArray*</a> <strong>searchers</strong> +); +</code></pre> +<dl> +<dt><emph>schema</emph></dt> +<dd><p>A Schema.</p> +</dd> +<dt><emph>searchers</emph></dt> +<dd><p>An array of Searchers.</p> +</dd> +</dl> +</dd> +</dl> +<h2>Methods</h2> +<h3>Methods inherited from Lucy::Search::Searcher</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>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>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> +<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::PolySearcher is a <a href="lucy_Searcher.html">Lucy::Search::Searcher</a> is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p> +</body> +</html> Added: websites/staging/lucy/trunk/content/docs/c/lucy_PostingList.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_PostingList.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_PostingList.html Sun Nov 23 17:43:07 2014 @@ -0,0 +1,131 @@ +<!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::PostingList</h1> +<h2>Name</h2> +<p>Lucy::Index::PostingList - Term-Document pairings.</p> +<h2>Description</h2> +<p>PostingList is an iterator which supplies a list of document ids that match +a given term.</p> +<p>See L<Lucy::Docs::IRTheory> for definitions of "posting" and "posting +list".</p> +<h2>Functions</h2> +<dl> +<dt>init</dt> +<dd> +<pre><code>lucy_PostingList* +<strong>lucy_PList_init</strong>( + lucy_PostingList* <strong>self</strong> +); +</code></pre> +</dd> +</dl> +<h2>Methods</h2> +<h3>Abstract methods</h3> +<dl> +<dt>Get_Doc_Freq</dt> +<dd> +<pre><code>uint32_t +<strong>LUCY_PList_Get_Doc_Freq</strong>( + lucy_PostingList* <strong>self</strong> +); +</code></pre> +<p>Return the number of documents that the PostingList contains. (This +number will include any documents which have been marked as deleted but +not yet purged.)</p> +</dd> +<dt>Seek</dt> +<dd> +<pre><code>void +<strong>LUCY_PList_Seek</strong>( + lucy_PostingList* <strong>self</strong>, + <a href="cfish_Obj.html">cfish_Obj*</a> <strong>target</strong> +); +</code></pre> +<p>Prepare the PostingList object to iterate over matches for documents +that match <code>target</code>.</p> +<dl> +<dt><emph>target</emph></dt> +<dd><p>The term to match. If NULL, the iterator will be empty.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Methods inherited from Lucy::Search::Matcher</h3><dl> +<dt>Next</dt> +<dd> +<pre><code>int32_t +<strong>LUCY_Matcher_Next</strong>( + lucy_Matcher* <strong>self</strong> +); +</code></pre> +<p>Proceed to the next doc id.</p> +<p><strong>Returns:</strong> A positive doc id, or 0 once the iterator is exhausted.</p> +</dd> +<dt>Advance</dt> +<dd> +<pre><code>int32_t +<strong>LUCY_Matcher_Advance</strong>( + lucy_Matcher* <strong>self</strong>, + int32_t <strong>target</strong> +); +</code></pre> +<p>Advance the iterator to the first doc id greater than or equal to +<code>target</code>. The default implementation simply calls Next() +over and over, but subclasses have the option of doing something more +efficient.</p> +<dl> +<dt><emph>target</emph></dt> +<dd><p>A positive doc id, which must be greater than the current +doc id once the iterator has been initialized.</p> +</dd> +</dl> +<p><strong>Returns:</strong> A positive doc id, or 0 once the iterator is exhausted.</p> +</dd> +<dt>Get_Doc_ID</dt> +<dd> +<pre><code>int32_t +<strong>LUCY_Matcher_Get_Doc_ID</strong>( + lucy_Matcher* <strong>self</strong> +); +</code></pre> +<p>Return the current doc id. Valid only after a successful call to +Next() or Advance() and must not be called otherwise.</p> +</dd> +<dt>Score</dt> +<dd> +<pre><code>float +<strong>LUCY_Matcher_Score</strong>( + lucy_Matcher* <strong>self</strong> +); +</code></pre> +<p>Return the score of the current document.</p> +<p>Only Matchers which are used for scored search need implement Score().</p> +</dd> +</dl> +<h2>Inheritance</h2> +<p>Lucy::Index::PostingList is a <a href="lucy_Matcher.html">Lucy::Search::Matcher</a> is a <a href="cfish_Obj.html">Clownfish::Obj</a>.</p> +</body> +</html> Added: websites/staging/lucy/trunk/content/docs/c/lucy_PostingListReader.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_PostingListReader.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_PostingListReader.html Sun Nov 23 17:43:07 2014 @@ -0,0 +1,148 @@ +<!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::PostingListReader</h1> +<h2>Name</h2> +<p>Lucy::Index::PostingListReader - Read postings data.</p> +<h2>Description</h2> +<p>PostingListReaders produce <a href="lucy_PostingList.html">PostingList</a> +objects which convey document matching information.</p> +<h2>Methods</h2> +<h3>Abstract methods</h3> +<dl> +<dt>Posting_List</dt> +<dd> +<pre><code><a href="lucy_PostingList.html">lucy_PostingList*</a> // incremented +<strong>LUCY_PListReader_Posting_List</strong>( + lucy_PostingListReader* <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>Returns a PostingList, or NULL if either <code>field</code> is NULL or +<code>field</code> is not present in any documents.</p> +<dl> +<dt><emph>field</emph></dt> +<dd><p>A field name.</p> +</dd> +<dt><emph>term</emph></dt> +<dd><p>If supplied, the PostingList will be pre-located to this +term using Seek().</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::PostingListReader 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: websites/staging/lucy/trunk/content/docs/c/lucy_ProximityQuery.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_ProximityQuery.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_ProximityQuery.html Sun Nov 23 17:43:07 2014 @@ -0,0 +1,170 @@ +<!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>LucyX::Search::ProximityQuery</h1> +<h2>Name</h2> +<p>LucyX::Search::ProximityQuery - Query matching an ordered list of terms.</p> +<h2>Description</h2> +<p>ProximityQuery is a subclass of <a href="lucy_Query.html">Query</a> for matching +against an ordered sequence of terms.</p> +<h2>Functions</h2> +<dl> +<dt>init</dt> +<dd> +<pre><code>lucy_ProximityQuery* +<strong>lucy_ProximityQuery_init</strong>( + lucy_ProximityQuery* <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>, + uint32_t <strong>within</strong> +); +</code></pre> +<dl> +<dt><emph>field</emph></dt> +<dd><p>The field that the phrase must occur in.</p> +</dd> +<dt><emph>terms</emph></dt> +<dd><p>The ordered array of terms that must match.</p> +</dd> +</dl> +</dd> +</dl> +<h2>Methods</h2> +<h3>Novel methods</h3> +<dl> +<dt>Get_Field</dt> +<dd> +<pre><code><a href="cfish_String.html">cfish_String*</a> +<strong>LUCY_ProximityQuery_Get_Field</strong>( + lucy_ProximityQuery* <strong>self</strong> +); +</code></pre> +<p>Accessor for object's field attribute.</p> +</dd> +<dt>Get_Terms</dt> +<dd> +<pre><code><a href="cfish_VArray.html">cfish_VArray*</a> +<strong>LUCY_ProximityQuery_Get_Terms</strong>( + lucy_ProximityQuery* <strong>self</strong> +); +</code></pre> +<p>Accessor for object's array of terms.</p> +</dd> +<dt>Get_Within</dt> +<dd> +<pre><code>uint32_t +<strong>LUCY_ProximityQuery_Get_Within</strong>( + lucy_ProximityQuery* <strong>self</strong> +); +</code></pre> +<p>Accessor for object's within attribute.</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>LucyX::Search::ProximityQuery 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: websites/staging/lucy/trunk/content/docs/c/lucy_Query.html ============================================================================== --- websites/staging/lucy/trunk/content/docs/c/lucy_Query.html (added) +++ websites/staging/lucy/trunk/content/docs/c/lucy_Query.html Sun Nov 23 17:43:07 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>