Added: lucy/site/trunk/content/docs/c/Lucy/Object/I32Array.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Object/I32Array.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Object/I32Array.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Object/I32Array.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,106 @@ +Title: Lucy::Object::I32Array â C API Documentation + +<div class="c-api"> +<h2>Lucy::Object::I32Array</h2> +<table> +<tr> +<td class="label">parcel</td> +<td><a href="../../lucy.html">Lucy</a></td> +</tr> +<tr> +<td class="label">class variable</td> +<td><code><span class="prefix">LUCY_</span>I32ARRAY</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>I32Array</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>I32Arr</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Object/I32Array.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Object::I32Array</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>I32Array* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>I32Arr_new</strong>( + int32_t *<strong>ints</strong>, + uint32_t <strong>size</strong> +); +</code></pre> +</dd> +<dt id="func_new_blank">new_blank</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>I32Array* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>I32Arr_new_blank</strong>( + uint32_t <strong>size</strong> +); +</code></pre> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>I32Array* +<span class="prefix">lucy_</span><strong>I32Arr_init</strong>( + <span class="prefix">lucy_</span>I32Array *<strong>self</strong>, + int32_t *<strong>ints</strong>, + uint32_t <strong>size</strong> +); +</code></pre> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Set">Set</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>I32Arr_Set</strong>( + <span class="prefix">lucy_</span>I32Array *<strong>self</strong>, + uint32_t <strong>tick</strong>, + int32_t <strong>value</strong> +); +</code></pre> +<p>Set the value at <code>tick</code>, or throw an error if +<code>tick</code> is out of bounds.</p> +</dd> +<dt id="func_Get">Get</dt> +<dd> +<pre><code>int32_t +<span class="prefix">lucy_</span><strong>I32Arr_Get</strong>( + <span class="prefix">lucy_</span>I32Array *<strong>self</strong>, + uint32_t <strong>tick</strong> +); +</code></pre> +<p>Return the value at <code>tick</code>, or throw an error if +<code>tick</code> is out of bounds.</p> +</dd> +<dt id="func_Get_Size">Get_Size</dt> +<dd> +<pre><code>uint32_t +<span class="prefix">lucy_</span><strong>I32Arr_Get_Size</strong>( + <span class="prefix">lucy_</span>I32Array *<strong>self</strong> +); +</code></pre> +<p>Accessor for âsizeâ member.</p> +</dd> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>I32Arr_Destroy</strong>( + <span class="prefix">lucy_</span>I32Array *<strong>self</strong> +); +</code></pre> +<p>Generic destructor. Frees the struct itself but not any complex +member elements.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Object::I32Array is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div>
Added: lucy/site/trunk/content/docs/c/Lucy/Plan/Architecture.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Plan/Architecture.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Plan/Architecture.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Plan/Architecture.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,102 @@ +Title: Lucy::Plan::Architecture â C API Documentation + +<div class="c-api"> +<h2>Lucy::Plan::Architecture</h2> +<table> +<tr> +<td class="label">parcel</td> +<td><a href="../../lucy.html">Lucy</a></td> +</tr> +<tr> +<td class="label">class variable</td> +<td><code><span class="prefix">LUCY_</span>ARCHITECTURE</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>Architecture</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>Arch</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Plan/Architecture.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Plan::Architecture â Configure major components of an index.</p> +<h3>Description</h3> +<p>By default, a Lucy index consists of several main parts: lexicon, +postings, stored documents, deletions, and highlight data. The readers and +writers for that data are spawned by Architecture. Each component operates +at the segment level; Architectureâs factory methods are used to build up +<a href="../../Lucy/Index/SegWriter.html">SegWriter</a> and +<a href="../../Lucy/Index/SegReader.html">SegReader</a>.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>Architecture* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>Arch_new</strong>(void); +</code></pre> +<p>Constructor. Takes no arguments.</p> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>Architecture* +<span class="prefix">lucy_</span><strong>Arch_init</strong>( + <span class="prefix">lucy_</span>Architecture *<strong>self</strong> +); +</code></pre> +<p>Initialize an Architecture.</p> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Register_Doc_Writer">Register_Doc_Writer</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Arch_Register_Doc_Writer</strong>( + <span class="prefix">lucy_</span>Architecture *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/SegWriter.html">SegWriter</a> *<strong>writer</strong> +); +</code></pre> +<p>Spawn a DataWriter and <a href="../../Lucy/Index/SegWriter.html#func_Register">Register()</a> it with the supplied SegWriter, +adding it to the SegWriterâs writer stack.</p> +<dl> +<dt>writer</dt> +<dd><p>A SegWriter.</p> +</dd> +</dl> +</dd> +<dt id="func_Register_Doc_Reader">Register_Doc_Reader</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Arch_Register_Doc_Reader</strong>( + <span class="prefix">lucy_</span>Architecture *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/SegReader.html">SegReader</a> *<strong>reader</strong> +); +</code></pre> +<p>Spawn a DocReader and register it with the supplied SegReader.</p> +<dl> +<dt>reader</dt> +<dd><p>A SegReader.</p> +</dd> +</dl> +</dd> +<dt id="func_Equals">Equals</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>Arch_Equals</strong>( + <span class="prefix">lucy_</span>Architecture *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>other</strong> +); +</code></pre> +<p>Returns true for any Architecture object. Subclasses should override +this weak check.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Plan::Architecture is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Plan/BlobType.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Plan/BlobType.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Plan/BlobType.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Plan/BlobType.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,98 @@ +Title: Lucy::Plan::BlobType â C API Documentation + +<div class="c-api"> +<h2>Lucy::Plan::BlobType</h2> +<table> +<tr> +<td class="label">parcel</td> +<td><a href="../../lucy.html">Lucy</a></td> +</tr> +<tr> +<td class="label">class variable</td> +<td><code><span class="prefix">LUCY_</span>BLOBTYPE</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>BlobType</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>BlobType</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Plan/BlobType.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Plan::BlobType â Default behaviors for binary fields.</p> +<h3>Description</h3> +<p>BlobType is an implementation of FieldType tuned for use with fields +containing binary data, which cannot be indexed or searched â only stored.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>BlobType* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>BlobType_new</strong>( + bool <strong>stored</strong> +); +</code></pre> +<p>Create a new BlobType.</p> +<dl> +<dt>stored</dt> +<dd><p>boolean indicating whether the field should be stored.</p> +</dd> +</dl> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>BlobType* +<span class="prefix">lucy_</span><strong>BlobType_init</strong>( + <span class="prefix">lucy_</span>BlobType *<strong>self</strong>, + bool <strong>stored</strong> +); +</code></pre> +<p>Initialize a BlobType.</p> +<dl> +<dt>stored</dt> +<dd><p>boolean indicating whether the field should be stored.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Binary">Binary</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>BlobType_Binary</strong>( + <span class="prefix">lucy_</span>BlobType *<strong>self</strong> +); +</code></pre> +<p>Returns true.</p> +</dd> +<dt id="func_Set_Sortable">Set_Sortable</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>BlobType_Set_Sortable</strong>( + <span class="prefix">lucy_</span>BlobType *<strong>self</strong>, + bool <strong>sortable</strong> +); +</code></pre> +<p>Throws an error unless <code>sortable</code> is false.</p> +</dd> +<dt id="func_Equals">Equals</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>BlobType_Equals</strong>( + <span class="prefix">lucy_</span>BlobType *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>other</strong> +); +</code></pre> +<p>Compares all common properties.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Plan::BlobType is a <a href="../../Lucy/Plan/FieldType.html">Lucy::Plan::FieldType</a> is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Plan/FieldType.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Plan/FieldType.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Plan/FieldType.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Plan/FieldType.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,151 @@ +Title: Lucy::Plan::FieldType â C API Documentation + +<div class="c-api"> +<h2>Lucy::Plan::FieldType</h2> +<table> +<tr> +<td class="label">parcel</td> +<td><a href="../../lucy.html">Lucy</a></td> +</tr> +<tr> +<td class="label">class variable</td> +<td><code><span class="prefix">LUCY_</span>FIELDTYPE</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>FieldType</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>FType</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Plan/FieldType.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Plan::FieldType â Define a fieldâs behavior.</p> +<h3>Description</h3> +<p>FieldType is an abstract class defining a set of traits and behaviors which +may be associated with one or more field names.</p> +<p>Properties which are common to all field types include <code>boost</code>, +<code>indexed</code>, <code>stored</code>, <code>sortable</code>, +<code>binary</code>, and <code>similarity</code>.</p> +<p>The <code>boost</code> property is a floating point scoring multiplier +which defaults to 1.0. Values greater than 1.0 cause the field to +contribute more to a documentâs score, lower values, less.</p> +<p>The <code>indexed</code> property indicates whether the field should be +indexed (so that it can be searched).</p> +<p>The <code>stored</code> property indicates whether to store the raw field +value, so that it can be retrieved when a document turns up in a search.</p> +<p>The <code>sortable</code> property indicates whether search results should +be sortable based on the contents of the field.</p> +<p>The <code>binary</code> property indicates whether the field contains +binary or text data. Unlike most other properties, <code>binary</code> is +not settable.</p> +<p>The <code>similarity</code> property is a +<a href="../../Lucy/Index/Similarity.html">Similarity</a> object which defines matching +and scoring behavior for the field. It is required if the field is +<code>indexed</code>.</p> +<h3>Methods</h3> +<dl> +<dt id="func_Set_Boost">Set_Boost</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>FType_Set_Boost</strong>( + <span class="prefix">lucy_</span>FieldType *<strong>self</strong>, + float <strong>boost</strong> +); +</code></pre> +<p>Setter for <code>boost</code>.</p> +</dd> +<dt id="func_Get_Boost">Get_Boost</dt> +<dd> +<pre><code>float +<span class="prefix">lucy_</span><strong>FType_Get_Boost</strong>( + <span class="prefix">lucy_</span>FieldType *<strong>self</strong> +); +</code></pre> +<p>Accessor for <code>boost</code>.</p> +</dd> +<dt id="func_Set_Indexed">Set_Indexed</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>FType_Set_Indexed</strong>( + <span class="prefix">lucy_</span>FieldType *<strong>self</strong>, + bool <strong>indexed</strong> +); +</code></pre> +<p>Setter for <code>indexed</code>.</p> +</dd> +<dt id="func_Indexed">Indexed</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>FType_Indexed</strong>( + <span class="prefix">lucy_</span>FieldType *<strong>self</strong> +); +</code></pre> +<p>Accessor for <code>indexed</code>.</p> +</dd> +<dt id="func_Set_Stored">Set_Stored</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>FType_Set_Stored</strong>( + <span class="prefix">lucy_</span>FieldType *<strong>self</strong>, + bool <strong>stored</strong> +); +</code></pre> +<p>Setter for <code>stored</code>.</p> +</dd> +<dt id="func_Stored">Stored</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>FType_Stored</strong>( + <span class="prefix">lucy_</span>FieldType *<strong>self</strong> +); +</code></pre> +<p>Accessor for <code>stored</code>.</p> +</dd> +<dt id="func_Set_Sortable">Set_Sortable</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>FType_Set_Sortable</strong>( + <span class="prefix">lucy_</span>FieldType *<strong>self</strong>, + bool <strong>sortable</strong> +); +</code></pre> +<p>Setter for <code>sortable</code>.</p> +</dd> +<dt id="func_Sortable">Sortable</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>FType_Sortable</strong>( + <span class="prefix">lucy_</span>FieldType *<strong>self</strong> +); +</code></pre> +<p>Accessor for <code>sortable</code>.</p> +</dd> +<dt id="func_Binary">Binary</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>FType_Binary</strong>( + <span class="prefix">lucy_</span>FieldType *<strong>self</strong> +); +</code></pre> +<p>Indicate whether the field contains binary data.</p> +</dd> +<dt id="func_Equals">Equals</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>FType_Equals</strong>( + <span class="prefix">lucy_</span>FieldType *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>other</strong> +); +</code></pre> +<p>Compares all common properties.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Plan::FieldType is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Plan/FullTextType.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Plan/FullTextType.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Plan/FullTextType.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Plan/FullTextType.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,149 @@ +Title: Lucy::Plan::FullTextType â C API Documentation + +<div class="c-api"> +<h2>Lucy::Plan::FullTextType</h2> +<table> +<tr> +<td class="label">parcel</td> +<td><a href="../../lucy.html">Lucy</a></td> +</tr> +<tr> +<td class="label">class variable</td> +<td><code><span class="prefix">LUCY_</span>FULLTEXTTYPE</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>FullTextType</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>FullTextType</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Plan/FullTextType.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Plan::FullTextType â Full-text search field type.</p> +<h3>Description</h3> +<p>Lucy::Plan::FullTextType is an implementation of +<a href="../../Lucy/Plan/FieldType.html">FieldType</a> tuned for âfull text searchâ.</p> +<p>Full text fields are associated with an +<a href="../../Lucy/Analysis/Analyzer.html">Analyzer</a>, which is used to tokenize and +normalize the text so that it can be searched for individual words.</p> +<p>For an exact-match, single value field type using character data, see +<a href="../../Lucy/Plan/StringType.html">StringType</a>.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>FullTextType* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>FullTextType_new</strong>( + <span class="prefix">lucy_</span><a href="../../Lucy/Analysis/Analyzer.html">Analyzer</a> *<strong>analyzer</strong> +); +</code></pre> +<p>Create a new FullTextType.</p> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>FullTextType* +<span class="prefix">lucy_</span><strong>FullTextType_init</strong>( + <span class="prefix">lucy_</span>FullTextType *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Analysis/Analyzer.html">Analyzer</a> *<strong>analyzer</strong> +); +</code></pre> +<p>Initialize a FullTextType.</p> +</dd> +<dt id="func_init2">init2</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>FullTextType* +<span class="prefix">lucy_</span><strong>FullTextType_init2</strong>( + <span class="prefix">lucy_</span>FullTextType *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Analysis/Analyzer.html">Analyzer</a> *<strong>analyzer</strong>, + float <strong>boost</strong>, + bool <strong>indexed</strong>, + bool <strong>stored</strong>, + bool <strong>sortable</strong>, + bool <strong>highlightable</strong> +); +</code></pre> +<dl> +<dt>analyzer</dt> +<dd><p>An Analyzer.</p> +</dd> +<dt>boost</dt> +<dd><p>floating point per-field boost.</p> +</dd> +<dt>indexed</dt> +<dd><p>boolean indicating whether the field should be indexed.</p> +</dd> +<dt>stored</dt> +<dd><p>boolean indicating whether the field should be stored.</p> +</dd> +<dt>sortable</dt> +<dd><p>boolean indicating whether the field should be sortable.</p> +</dd> +<dt>highlightable</dt> +<dd><p>boolean indicating whether the field should be +highlightable.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Set_Highlightable">Set_Highlightable</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>FullTextType_Set_Highlightable</strong>( + <span class="prefix">lucy_</span>FullTextType *<strong>self</strong>, + bool <strong>highlightable</strong> +); +</code></pre> +<p>Indicate whether to store data required by +<a href="../../Lucy/Highlight/Highlighter.html">Highlighter</a> for excerpt selection and search +term highlighting.</p> +</dd> +<dt id="func_Highlightable">Highlightable</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>FullTextType_Highlightable</strong>( + <span class="prefix">lucy_</span>FullTextType *<strong>self</strong> +); +</code></pre> +<p>Accessor for âhighlightableâ property.</p> +</dd> +<dt id="func_Get_Analyzer">Get_Analyzer</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Analysis/Analyzer.html">Analyzer</a>* +<span class="prefix">lucy_</span><strong>FullTextType_Get_Analyzer</strong>( + <span class="prefix">lucy_</span>FullTextType *<strong>self</strong> +); +</code></pre> +<p>Accessor for the typeâs analyzer.</p> +</dd> +<dt id="func_Equals">Equals</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>FullTextType_Equals</strong>( + <span class="prefix">lucy_</span>FullTextType *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>other</strong> +); +</code></pre> +<p>Compares all common properties.</p> +</dd> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>FullTextType_Destroy</strong>( + <span class="prefix">lucy_</span>FullTextType *<strong>self</strong> +); +</code></pre> +<p>Generic destructor. Frees the struct itself but not any complex +member elements.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Plan::FullTextType is a <a href="../../Lucy/Plan/TextType.html">Lucy::Plan::TextType</a> is a <a href="../../Lucy/Plan/FieldType.html">Lucy::Plan::FieldType</a> is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Plan/Schema.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Plan/Schema.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Plan/Schema.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Plan/Schema.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,159 @@ +Title: Lucy::Plan::Schema â C API Documentation + +<div class="c-api"> +<h2>Lucy::Plan::Schema</h2> +<table> +<tr> +<td class="label">parcel</td> +<td><a href="../../lucy.html">Lucy</a></td> +</tr> +<tr> +<td class="label">class variable</td> +<td><code><span class="prefix">LUCY_</span>SCHEMA</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>Schema</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>Schema</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Plan/Schema.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Plan::Schema â User-created specification for an inverted index.</p> +<h3>Description</h3> +<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> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>Schema* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>Schema_new</strong>(void); +</code></pre> +<p>Constructor. Takes no arguments.</p> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>Schema* +<span class="prefix">lucy_</span><strong>Schema_init</strong>( + <span class="prefix">lucy_</span>Schema *<strong>self</strong> +); +</code></pre> +<p>Initialize a Schema.</p> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Architecture">Architecture</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Plan/Architecture.html">Architecture</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>Schema_Architecture</strong>( + <span class="prefix">lucy_</span>Schema *<strong>self</strong> +); +</code></pre> +<p>Factory method which creates an Architecture object for this index.</p> +</dd> +<dt id="func_Spec_Field">Spec_Field</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Schema_Spec_Field</strong>( + <span class="prefix">lucy_</span>Schema *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>name</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Plan/FieldType.html">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 <a href="../../Lucy/Plan/Schema.html#func_Equals">Equals()</a> the existing one.</p> +<dl> +<dt>name</dt> +<dd><p>The name of the field.</p> +</dd> +<dt>type</dt> +<dd><p>A FieldType.</p> +</dd> +</dl> +</dd> +<dt id="func_Fetch_Type">Fetch_Type</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Plan/FieldType.html">FieldType</a>* +<span class="prefix">lucy_</span><strong>Schema_Fetch_Type</strong>( + <span class="prefix">lucy_</span>Schema *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">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 id="func_Fetch_Sim">Fetch_Sim</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Index/Similarity.html">Similarity</a>* +<span class="prefix">lucy_</span><strong>Schema_Fetch_Sim</strong>( + <span class="prefix">lucy_</span>Schema *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">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 id="func_Num_Fields">Num_Fields</dt> +<dd> +<pre><code>uint32_t +<span class="prefix">lucy_</span><strong>Schema_Num_Fields</strong>( + <span class="prefix">lucy_</span>Schema *<strong>self</strong> +); +</code></pre> +<p>Return the number of fields currently defined.</p> +</dd> +<dt id="func_All_Fields">All_Fields</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/Vector.html">Vector</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>Schema_All_Fields</strong>( + <span class="prefix">lucy_</span>Schema *<strong>self</strong> +); +</code></pre> +<p>Return all the Schemaâs field names as an array.</p> +</dd> +<dt id="func_Get_Architecture">Get_Architecture</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Plan/Architecture.html">Architecture</a>* +<span class="prefix">lucy_</span><strong>Schema_Get_Architecture</strong>( + <span class="prefix">lucy_</span>Schema *<strong>self</strong> +); +</code></pre> +<p>Return the Schema instanceâs internal Architecture object.</p> +</dd> +<dt id="func_Get_Similarity">Get_Similarity</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Index/Similarity.html">Similarity</a>* +<span class="prefix">lucy_</span><strong>Schema_Get_Similarity</strong>( + <span class="prefix">lucy_</span>Schema *<strong>self</strong> +); +</code></pre> +<p>Return the Schema instanceâs internal Similarity object.</p> +</dd> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Schema_Destroy</strong>( + <span class="prefix">lucy_</span>Schema *<strong>self</strong> +); +</code></pre> +<p>Generic destructor. Frees the struct itself but not any complex +member elements.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Plan::Schema is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Plan/StringType.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Plan/StringType.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Plan/StringType.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Plan/StringType.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,92 @@ +Title: Lucy::Plan::StringType â C API Documentation + +<div class="c-api"> +<h2>Lucy::Plan::StringType</h2> +<table> +<tr> +<td class="label">parcel</td> +<td><a href="../../lucy.html">Lucy</a></td> +</tr> +<tr> +<td class="label">class variable</td> +<td><code><span class="prefix">LUCY_</span>STRINGTYPE</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>StringType</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>StringType</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Plan/StringType.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Plan::StringType â Non-tokenized text type.</p> +<h3>Description</h3> +<p>Lucy::Plan::StringType is used for âexact-matchâ strings.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>StringType* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>StringType_new</strong>(void); +</code></pre> +<p>Create a new StringType.</p> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>StringType* +<span class="prefix">lucy_</span><strong>StringType_init</strong>( + <span class="prefix">lucy_</span>StringType *<strong>self</strong> +); +</code></pre> +<p>Initialize a StringType.</p> +</dd> +<dt id="func_init2">init2</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>StringType* +<span class="prefix">lucy_</span><strong>StringType_init2</strong>( + <span class="prefix">lucy_</span>StringType *<strong>self</strong>, + float <strong>boost</strong>, + bool <strong>indexed</strong>, + bool <strong>stored</strong>, + bool <strong>sortable</strong> +); +</code></pre> +<dl> +<dt>boost</dt> +<dd><p>floating point per-field boost.</p> +</dd> +<dt>indexed</dt> +<dd><p>boolean indicating whether the field should be indexed.</p> +</dd> +<dt>stored</dt> +<dd><p>boolean indicating whether the field should be stored.</p> +</dd> +<dt>sortable</dt> +<dd><p>boolean indicating whether the field should be +sortable.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Equals">Equals</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>StringType_Equals</strong>( + <span class="prefix">lucy_</span>StringType *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>other</strong> +); +</code></pre> +<p>Compares all common properties.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Plan::StringType is a <a href="../../Lucy/Plan/TextType.html">Lucy::Plan::TextType</a> is a <a href="../../Lucy/Plan/FieldType.html">Lucy::Plan::FieldType</a> is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Search/ANDQuery.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Search/ANDQuery.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Search/ANDQuery.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Search/ANDQuery.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,121 @@ +Title: Lucy::Search::ANDQuery â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::ANDQuery</h2> +<table> +<tr> +<td class="label">parcel</td> +<td><a href="../../lucy.html">Lucy</a></td> +</tr> +<tr> +<td class="label">class variable</td> +<td><code><span class="prefix">LUCY_</span>ANDQUERY</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>ANDQuery</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>ANDQuery</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/ANDQuery.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::ANDQuery â Intersect multiple result sets.</p> +<h3>Description</h3> +<p>ANDQuery is a composite <a href="../../Lucy/Search/Query.html">Query</a> which matches +only when all of its children match, so its result set is the intersection +of their result sets. Documents which match receive a summed score.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>ANDQuery* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>ANDQuery_new</strong>( + <span class="prefix">cfish_</span><a href="../../Clownfish/Vector.html">Vector</a> *<strong>children</strong> +); +</code></pre> +<p>Create a new ANDQuery.</p> +<dl> +<dt>children</dt> +<dd><p>An array of child Queries.</p> +</dd> +</dl> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>ANDQuery* +<span class="prefix">lucy_</span><strong>ANDQuery_init</strong>( + <span class="prefix">lucy_</span>ANDQuery *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Vector.html">Vector</a> *<strong>children</strong> +); +</code></pre> +<p>Initialize an ANDQuery.</p> +<dl> +<dt>children</dt> +<dd><p>An array of child Queries.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Make_Compiler">Make_Compiler</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Compiler.html">Compiler</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>ANDQuery_Make_Compiler</strong>( + <span class="prefix">lucy_</span>ANDQuery *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Searcher.html">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>searcher</dt> +<dd><p>A Searcher.</p> +</dd> +<dt>boost</dt> +<dd><p>A scoring multiplier.</p> +</dd> +<dt>subordinate</dt> +<dd><p>Indicates whether the Query is a subquery (as +opposed to a top-level query). If false, the implementation must +invoke <a href="../../Lucy/Search/Compiler.html#func_Normalize">Normalize()</a> on the newly minted Compiler object before returning +it.</p> +</dd> +</dl> +</dd> +<dt id="func_To_String">To_String</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>ANDQuery_To_String</strong>( + <span class="prefix">lucy_</span>ANDQuery *<strong>self</strong> +); +</code></pre> +<p>Generic stringification: âClassName@hex_mem_addressâ.</p> +</dd> +<dt id="func_Equals">Equals</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>ANDQuery_Equals</strong>( + <span class="prefix">lucy_</span>ANDQuery *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>other</strong> +); +</code></pre> +<p>Indicate whether two objects are the same. By default, compares the +memory address.</p> +<dl> +<dt>other</dt> +<dd><p>Another Obj.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::ANDQuery is a <a href="../../Lucy/Search/PolyQuery.html">Lucy::Search::PolyQuery</a> is a <a href="../../Lucy/Search/Query.html">Lucy::Search::Query</a> is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Search/Collector.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Search/Collector.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Search/Collector.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Search/Collector.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,80 @@ +Title: Lucy::Search::Collector â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::Collector</h2> +<table> +<tr> +<td class="label">parcel</td> +<td><a href="../../lucy.html">Lucy</a></td> +</tr> +<tr> +<td class="label">class variable</td> +<td><code><span class="prefix">LUCY_</span>COLLECTOR</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>Collector</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>Coll</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/Collector.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::Collector â Process hits.</p> +<h3>Description</h3> +<p>A Collector decides what to do with the hits that a +<a href="../../Lucy/Search/Matcher.html">Matcher</a> iterates through, based on how the +abstract <a href="../../Lucy/Search/Collector.html#func_Collect">Collect()</a> method is implemented.</p> +<p>Collectors operate on individual segments, but must operate within the +context of a larger collection. Each time the collector moves to a new +segment, Set_Reader(), Set_Base() and Set_Matcher() will be called, and the +collector must take the updated information into account.</p> +<h3>Functions</h3> +<dl> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>Collector* +<span class="prefix">lucy_</span><strong>Coll_init</strong>( + <span class="prefix">lucy_</span>Collector *<strong>self</strong> +); +</code></pre> +<p>Abstract initializer.</p> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Coll_Destroy</strong>( + <span class="prefix">lucy_</span>Collector *<strong>self</strong> +); +</code></pre> +<p>Generic destructor. Frees the struct itself but not any complex +member elements.</p> +</dd> +<dt id="func_Collect">Collect <span class="comment">(abstract)</span></dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Coll_Collect</strong>( + <span class="prefix">lucy_</span>Collector *<strong>self</strong>, + int32_t <strong>doc_id</strong> +); +</code></pre> +<p>Do something with a doc id. (For instance, keep track of the docs +with the ten highest scores.)</p> +<dl> +<dt>doc_id</dt> +<dd><p>A segment document id.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::Collector is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Search/Collector/BitCollector.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Search/Collector/BitCollector.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Search/Collector/BitCollector.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Search/Collector/BitCollector.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,90 @@ +Title: Lucy::Search::Collector::BitCollector â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::Collector::BitCollector</h2> +<table> +<tr> +<td class="label">parcel</td> +<td><a href="../../../lucy.html">Lucy</a></td> +</tr> +<tr> +<td class="label">class variable</td> +<td><code><span class="prefix">LUCY_</span>BITCOLLECTOR</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>BitCollector</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>BitColl</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/Collector.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::Collector::BitCollector â Collector which records doc nums in a BitVector.</p> +<h3>Description</h3> +<p>BitCollector is a Collector which saves matching document ids in a +<a href="../../../Lucy/Object/BitVector.html">BitVector</a>. It is useful for recording the +entire set of documents which matches a query.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>BitCollector* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>BitColl_new</strong>( + <span class="prefix">lucy_</span><a href="../../../Lucy/Object/BitVector.html">BitVector</a> *<strong>bit_vector</strong> +); +</code></pre> +<p>Create a new BitCollector.</p> +<dl> +<dt>bit_vector</dt> +<dd><p>A Lucy::Object::BitVector.</p> +</dd> +</dl> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>BitCollector* +<span class="prefix">lucy_</span><strong>BitColl_init</strong>( + <span class="prefix">lucy_</span>BitCollector *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../../Lucy/Object/BitVector.html">BitVector</a> *<strong>bit_vector</strong> +); +</code></pre> +<p>Initialize a BitCollector.</p> +<dl> +<dt>bit_vector</dt> +<dd><p>A Lucy::Object::BitVector.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>BitColl_Destroy</strong>( + <span class="prefix">lucy_</span>BitCollector *<strong>self</strong> +); +</code></pre> +<p>Generic destructor. Frees the struct itself but not any complex +member elements.</p> +</dd> +<dt id="func_Collect">Collect</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>BitColl_Collect</strong>( + <span class="prefix">lucy_</span>BitCollector *<strong>self</strong>, + int32_t <strong>doc_id</strong> +); +</code></pre> +<p>Set bit in the objectâs BitVector for the supplied doc id.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::Collector::BitCollector is a <a href="../../../Lucy/Search/Collector.html">Lucy::Search::Collector</a> is a <a href="../../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Search/Compiler.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Search/Compiler.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Search/Compiler.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Search/Compiler.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,232 @@ +Title: Lucy::Search::Compiler â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::Compiler</h2> +<table> +<tr> +<td class="label">parcel</td> +<td><a href="../../lucy.html">Lucy</a></td> +</tr> +<tr> +<td class="label">class variable</td> +<td><code><span class="prefix">LUCY_</span>COMPILER</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>Compiler</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>Compiler</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/Compiler.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::Compiler â Query-to-Matcher compiler.</p> +<h3>Description</h3> +<p>The purpose of the Compiler class is to take a specification in the form of +a <a href="../../Lucy/Search/Query.html">Query</a> object and compile a +<a href="../../Lucy/Search/Matcher.html">Matcher</a> object that can do real work.</p> +<p>The simplest Compiler subclasses â such as those associated with +constant-scoring Query types â might simply implement a <a href="../../Lucy/Search/Compiler.html#func_Make_Matcher">Make_Matcher()</a> +method which passes along information verbatim from the Query to the +Matcherâs constructor.</p> +<p>However it is common for the Compiler to perform some calculations which +affect itâs âweightâ â a floating point multiplier that the Matcher will +factor into each documentâs score. If that is the case, then the Compiler +subclass may wish to override <a href="../../Lucy/Search/Compiler.html#func_Get_Weight">Get_Weight()</a>, <a href="../../Lucy/Search/Compiler.html#func_Sum_Of_Squared_Weights">Sum_Of_Squared_Weights()</a>, and +<a href="../../Lucy/Search/Compiler.html#func_Apply_Norm_Factor">Apply_Norm_Factor()</a>.</p> +<p>Compiling a Matcher is a two stage process.</p> +<p>The first stage takes place during the Compilerâs construction, which is +where the Query object meets a <a href="../../Lucy/Search/Searcher.html">Searcher</a> +object for the first time. Searchers operate on a specific document +collection and they can tell you certain statistical information about the +collection â such as how many total documents are in the collection, or +how many documents in the collection a particular term is present in. +Lucyâs core Compiler classes plug this information into the classic +TF/IDF weighting algorithm to adjust the Compilerâs weight; custom +subclasses might do something similar.</p> +<p>The second stage of compilation is <a href="../../Lucy/Search/Compiler.html#func_Make_Matcher">Make_Matcher()</a>, method, which is where +the Compiler meets a <a href="../../Lucy/Index/SegReader.html">SegReader</a> object. +SegReaders are associated with a single segment within a single index on a +single machine, and are thus lower-level than Searchers, which may +represent a document collection spread out over a search cluster +(comprising several indexes and many segments). The Compiler object can +use new information supplied by the SegReader â such as whether a term is +missing from the local index even though it is present within the larger +collection represented by the Searcher â when figuring out what to feed to +the Matchersâs constructor, or whether <a href="../../Lucy/Search/Compiler.html#func_Make_Matcher">Make_Matcher()</a> should return a +Matcher at all.</p> +<h3>Functions</h3> +<dl> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>Compiler* +<span class="prefix">lucy_</span><strong>Compiler_init</strong>( + <span class="prefix">lucy_</span>Compiler *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>parent</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Searcher.html">Searcher</a> *<strong>searcher</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/Similarity.html">Similarity</a> *<strong>similarity</strong>, + float <strong>boost</strong> +); +</code></pre> +<p>Abstract initializer.</p> +<dl> +<dt>parent</dt> +<dd><p>The parent Query.</p> +</dd> +<dt>searcher</dt> +<dd><p>A Lucy::Search::Searcher, such as an +IndexSearcher.</p> +</dd> +<dt>similarity</dt> +<dd><p>A Similarity.</p> +</dd> +<dt>boost</dt> +<dd><p>An arbitrary scoring multiplier. Defaults to the boost of +the parent Query.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Make_Matcher">Make_Matcher <span class="comment">(abstract)</span></dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Matcher.html">Matcher</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>Compiler_Make_Matcher</strong>( + <span class="prefix">lucy_</span>Compiler *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/SegReader.html">SegReader</a> *<strong>reader</strong>, + bool <strong>need_score</strong> +); +</code></pre> +<p>Factory method returning a Matcher.</p> +<dl> +<dt>reader</dt> +<dd><p>A SegReader.</p> +</dd> +<dt>need_score</dt> +<dd><p>Indicate whether the Matcher must implement <a href="../../Lucy/Search/Matcher.html#func_Score">Score()</a>.</p> +</dd> +</dl> +<p><strong>Returns:</strong> a Matcher, or NULL if the Matcher would have matched +no documents.</p> +</dd> +<dt id="func_Get_Weight">Get_Weight</dt> +<dd> +<pre><code>float +<span class="prefix">lucy_</span><strong>Compiler_Get_Weight</strong>( + <span class="prefix">lucy_</span>Compiler *<strong>self</strong> +); +</code></pre> +<p>Return the Compilerâs numerical weight, a scoring multiplier. By +default, returns the objectâs boost.</p> +</dd> +<dt id="func_Get_Similarity">Get_Similarity</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Index/Similarity.html">Similarity</a>* +<span class="prefix">lucy_</span><strong>Compiler_Get_Similarity</strong>( + <span class="prefix">lucy_</span>Compiler *<strong>self</strong> +); +</code></pre> +<p>Accessor for the Compilerâs Similarity object.</p> +</dd> +<dt id="func_Get_Parent">Get_Parent</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a>* +<span class="prefix">lucy_</span><strong>Compiler_Get_Parent</strong>( + <span class="prefix">lucy_</span>Compiler *<strong>self</strong> +); +</code></pre> +<p>Accessor for the Compilerâs parent Query object.</p> +</dd> +<dt id="func_Sum_Of_Squared_Weights">Sum_Of_Squared_Weights</dt> +<dd> +<pre><code>float +<span class="prefix">lucy_</span><strong>Compiler_Sum_Of_Squared_Weights</strong>( + <span class="prefix">lucy_</span>Compiler *<strong>self</strong> +); +</code></pre> +<p>Compute and return a raw weighting factor. (This quantity is used by +<a href="../../Lucy/Search/Compiler.html#func_Normalize">Normalize()</a>). By default, simply returns 1.0.</p> +</dd> +<dt id="func_Apply_Norm_Factor">Apply_Norm_Factor</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Compiler_Apply_Norm_Factor</strong>( + <span class="prefix">lucy_</span>Compiler *<strong>self</strong>, + float <strong>factor</strong> +); +</code></pre> +<p>Apply a floating point normalization multiplier. For a TermCompiler, +this involves multiplying its own weight by the supplied factor; +combining classes such as ORCompiler would apply the factor recursively +to their children.</p> +<p>The default implementation is a no-op; subclasses may wish to multiply +their internal weight by the supplied factor.</p> +<dl> +<dt>factor</dt> +<dd><p>The multiplier.</p> +</dd> +</dl> +</dd> +<dt id="func_Normalize">Normalize</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Compiler_Normalize</strong>( + <span class="prefix">lucy_</span>Compiler *<strong>self</strong> +); +</code></pre> +<p>Take a newly minted Compiler object and apply query-specific +normalization factors. Should be invoked by Query subclasses during +<a href="../../Lucy/Search/Compiler.html#func_Make_Compiler">Make_Compiler()</a> for top-level nodes.</p> +<p>For a TermQuery, the scoring formula is approximately:</p> +<pre><code>(tf_d * idf_t / norm_d) * (tf_q * idf_t / norm_q) +</code></pre> +<p><a href="../../Lucy/Search/Compiler.html#func_Normalize">Normalize()</a> is theoretically concerned with applying the second half of +that formula to a the Compilerâs weight. What actually happens depends +on how the Compiler and Similarity methods called internally are +implemented.</p> +</dd> +<dt id="func_Equals">Equals</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>Compiler_Equals</strong>( + <span class="prefix">lucy_</span>Compiler *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>other</strong> +); +</code></pre> +<p>Indicate whether two objects are the same. By default, compares the +memory address.</p> +<dl> +<dt>other</dt> +<dd><p>Another Obj.</p> +</dd> +</dl> +</dd> +<dt id="func_To_String">To_String</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>Compiler_To_String</strong>( + <span class="prefix">lucy_</span>Compiler *<strong>self</strong> +); +</code></pre> +<p>Generic stringification: âClassName@hex_mem_addressâ.</p> +</dd> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Compiler_Destroy</strong>( + <span class="prefix">lucy_</span>Compiler *<strong>self</strong> +); +</code></pre> +<p>Generic destructor. Frees the struct itself but not any complex +member elements.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::Compiler is a <a href="../../Lucy/Search/Query.html">Lucy::Search::Query</a> is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Search/Hits.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Search/Hits.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Search/Hits.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Search/Hits.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,67 @@ +Title: Lucy::Search::Hits â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::Hits</h2> +<table> +<tr> +<td class="label">parcel</td> +<td><a href="../../lucy.html">Lucy</a></td> +</tr> +<tr> +<td class="label">class variable</td> +<td><code><span class="prefix">LUCY_</span>HITS</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>Hits</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>Hits</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/Hits.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::Hits â Access search results.</p> +<h3>Description</h3> +<p>Hits objects are iterators used to access the results of a search.</p> +<h3>Methods</h3> +<dl> +<dt id="func_Next">Next</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Document/HitDoc.html">HitDoc</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>Hits_Next</strong>( + <span class="prefix">lucy_</span>Hits *<strong>self</strong> +); +</code></pre> +<p>Return the next hit, or NULL when the iterator is exhausted.</p> +</dd> +<dt id="func_Total_Hits">Total_Hits</dt> +<dd> +<pre><code>uint32_t +<span class="prefix">lucy_</span><strong>Hits_Total_Hits</strong>( + <span class="prefix">lucy_</span>Hits *<strong>self</strong> +); +</code></pre> +<p>Return the total number of documents which matched the Query used to +produce the Hits object. Note that this is the total number of +matches, not just the number of matches represented by the Hits +iterator.</p> +</dd> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Hits_Destroy</strong>( + <span class="prefix">lucy_</span>Hits *<strong>self</strong> +); +</code></pre> +<p>Generic destructor. Frees the struct itself but not any complex +member elements.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::Hits is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Search/IndexSearcher.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Search/IndexSearcher.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Search/IndexSearcher.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Search/IndexSearcher.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,159 @@ +Title: Lucy::Search::IndexSearcher â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::IndexSearcher</h2> +<table> +<tr> +<td class="label">parcel</td> +<td><a href="../../lucy.html">Lucy</a></td> +</tr> +<tr> +<td class="label">class variable</td> +<td><code><span class="prefix">LUCY_</span>INDEXSEARCHER</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>IndexSearcher</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>IxSearcher</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/IndexSearcher.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::IndexSearcher â Execute searches against a single index.</p> +<h3>Description</h3> +<p>Use the IndexSearcher class to perform search queries against an index. +(For searching multiple indexes at once, see +<a href="../../Lucy/Search/PolySearcher.html">PolySearcher</a>).</p> +<p>IndexSearchers operate against a single point-in-time view or +<a href="../../Lucy/Index/Snapshot.html">Snapshot</a> of the index. If an index is +modified, a new IndexSearcher must be opened to access the changes.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>IndexSearcher* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>IxSearcher_new</strong>( + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>index</strong> +); +</code></pre> +<p>Create a new IndexSearcher.</p> +<dl> +<dt>index</dt> +<dd><p>Either a string filepath, a Folder, or an IndexReader.</p> +</dd> +</dl> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>IndexSearcher* +<span class="prefix">lucy_</span><strong>IxSearcher_init</strong>( + <span class="prefix">lucy_</span>IndexSearcher *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>index</strong> +); +</code></pre> +<p>Initialize an IndexSearcher.</p> +<dl> +<dt>index</dt> +<dd><p>Either a string filepath, a Folder, or an IndexReader.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>IxSearcher_Destroy</strong>( + <span class="prefix">lucy_</span>IndexSearcher *<strong>self</strong> +); +</code></pre> +<p>Generic destructor. Frees the struct itself but not any complex +member elements.</p> +</dd> +<dt id="func_Doc_Max">Doc_Max</dt> +<dd> +<pre><code>int32_t +<span class="prefix">lucy_</span><strong>IxSearcher_Doc_Max</strong>( + <span class="prefix">lucy_</span>IndexSearcher *<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 id="func_Doc_Freq">Doc_Freq</dt> +<dd> +<pre><code>uint32_t +<span class="prefix">lucy_</span><strong>IxSearcher_Doc_Freq</strong>( + <span class="prefix">lucy_</span>IndexSearcher *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>field</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>term</strong> +); +</code></pre> +<p>Return the number of documents which contain the term in the given +field.</p> +<dl> +<dt>field</dt> +<dd><p>Field name.</p> +</dd> +<dt>term</dt> +<dd><p>The term to look up.</p> +</dd> +</dl> +</dd> +<dt id="func_Collect">Collect</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>IxSearcher_Collect</strong>( + <span class="prefix">lucy_</span>IndexSearcher *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>query</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Collector.html">Collector</a> *<strong>collector</strong> +); +</code></pre> +<p>Iterate over hits, feeding them into a +<a href="../../Lucy/Search/Collector.html">Collector</a>.</p> +<dl> +<dt>query</dt> +<dd><p>A Query.</p> +</dd> +<dt>collector</dt> +<dd><p>A Collector.</p> +</dd> +</dl> +</dd> +<dt id="func_Fetch_Doc">Fetch_Doc</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Document/HitDoc.html">HitDoc</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>IxSearcher_Fetch_Doc</strong>( + <span class="prefix">lucy_</span>IndexSearcher *<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>doc_id</dt> +<dd><p>A document id.</p> +</dd> +</dl> +</dd> +<dt id="func_Get_Reader">Get_Reader</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Index/IndexReader.html">IndexReader</a>* +<span class="prefix">lucy_</span><strong>IxSearcher_Get_Reader</strong>( + <span class="prefix">lucy_</span>IndexSearcher *<strong>self</strong> +); +</code></pre> +<p>Accessor for the objectâs <code>reader</code> member.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::IndexSearcher is a <a href="../../Lucy/Search/Searcher.html">Lucy::Search::Searcher</a> is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Search/LeafQuery.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Search/LeafQuery.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Search/LeafQuery.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Search/LeafQuery.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,163 @@ +Title: Lucy::Search::LeafQuery â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::LeafQuery</h2> +<table> +<tr> +<td class="label">parcel</td> +<td><a href="../../lucy.html">Lucy</a></td> +</tr> +<tr> +<td class="label">class variable</td> +<td><code><span class="prefix">LUCY_</span>LEAFQUERY</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>LeafQuery</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>LeafQuery</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/LeafQuery.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::LeafQuery â Leaf node in a tree created by QueryParser.</p> +<h3>Description</h3> +<p>LeafQuery objects serve as leaf nodes in the tree structure generated by +<a href="../../Lucy/Search/QueryParser.html">QueryParser</a>âs <a href="../../Lucy/Search/QueryParser.html#func_Tree">Tree()</a> method. +Ultimately, they must be transformed, typically into either +<a href="../../Lucy/Search/TermQuery.html">TermQuery</a> or +<a href="../../Lucy/Search/PhraseQuery.html">PhraseQuery</a> objects, as attempting to +search a LeafQuery causes an error.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>LeafQuery* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>LeafQuery_new</strong>( + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>field</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>text</strong> +); +</code></pre> +<p>Create a new LeafQuery.</p> +<dl> +<dt>field</dt> +<dd><p>Optional field name.</p> +</dd> +<dt>text</dt> +<dd><p>Raw query text.</p> +</dd> +</dl> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>LeafQuery* +<span class="prefix">lucy_</span><strong>LeafQuery_init</strong>( + <span class="prefix">lucy_</span>LeafQuery *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>field</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>text</strong> +); +</code></pre> +<p>Initialize a LeafQuery.</p> +<dl> +<dt>field</dt> +<dd><p>Optional field name.</p> +</dd> +<dt>text</dt> +<dd><p>Raw query text.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Get_Field">Get_Field</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a>* +<span class="prefix">lucy_</span><strong>LeafQuery_Get_Field</strong>( + <span class="prefix">lucy_</span>LeafQuery *<strong>self</strong> +); +</code></pre> +<p>Accessor for objectâs <code>field</code> attribute.</p> +</dd> +<dt id="func_Get_Text">Get_Text</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a>* +<span class="prefix">lucy_</span><strong>LeafQuery_Get_Text</strong>( + <span class="prefix">lucy_</span>LeafQuery *<strong>self</strong> +); +</code></pre> +<p>Accessor for objectâs <code>text</code> attribute.</p> +</dd> +<dt id="func_Equals">Equals</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>LeafQuery_Equals</strong>( + <span class="prefix">lucy_</span>LeafQuery *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>other</strong> +); +</code></pre> +<p>Indicate whether two objects are the same. By default, compares the +memory address.</p> +<dl> +<dt>other</dt> +<dd><p>Another Obj.</p> +</dd> +</dl> +</dd> +<dt id="func_To_String">To_String</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>LeafQuery_To_String</strong>( + <span class="prefix">lucy_</span>LeafQuery *<strong>self</strong> +); +</code></pre> +<p>Generic stringification: âClassName@hex_mem_addressâ.</p> +</dd> +<dt id="func_Dump">Dump</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>LeafQuery_Dump</strong>( + <span class="prefix">lucy_</span>LeafQuery *<strong>self</strong> +); +</code></pre> +</dd> +<dt id="func_Load">Load</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>LeafQuery_Load</strong>( + <span class="prefix">lucy_</span>LeafQuery *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>dump</strong> +); +</code></pre> +</dd> +<dt id="func_Make_Compiler">Make_Compiler</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Compiler.html">Compiler</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>LeafQuery_Make_Compiler</strong>( + <span class="prefix">lucy_</span>LeafQuery *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Searcher.html">Searcher</a> *<strong>searcher</strong>, + float <strong>boost</strong>, + bool <strong>subordinate</strong> +); +</code></pre> +<p>Throws an error.</p> +</dd> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>LeafQuery_Destroy</strong>( + <span class="prefix">lucy_</span>LeafQuery *<strong>self</strong> +); +</code></pre> +<p>Generic destructor. Frees the struct itself but not any complex +member elements.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::LeafQuery is a <a href="../../Lucy/Search/Query.html">Lucy::Search::Query</a> is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Search/MatchAllQuery.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Search/MatchAllQuery.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Search/MatchAllQuery.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Search/MatchAllQuery.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,109 @@ +Title: Lucy::Search::MatchAllQuery â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::MatchAllQuery</h2> +<table> +<tr> +<td class="label">parcel</td> +<td><a href="../../lucy.html">Lucy</a></td> +</tr> +<tr> +<td class="label">class variable</td> +<td><code><span class="prefix">LUCY_</span>MATCHALLQUERY</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>MatchAllQuery</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>MatchAllQuery</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/MatchAllQuery.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::MatchAllQuery â Query which matches all documents.</p> +<h3>Description</h3> +<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> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>MatchAllQuery* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>MatchAllQuery_new</strong>(void); +</code></pre> +<p>Constructor. Takes no arguments.</p> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>MatchAllQuery* +<span class="prefix">lucy_</span><strong>MatchAllQuery_init</strong>( + <span class="prefix">lucy_</span>MatchAllQuery *<strong>self</strong> +); +</code></pre> +<p>Initialize a MatchAllQuery.</p> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Equals">Equals</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>MatchAllQuery_Equals</strong>( + <span class="prefix">lucy_</span>MatchAllQuery *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>other</strong> +); +</code></pre> +<p>Indicate whether two objects are the same. By default, compares the +memory address.</p> +<dl> +<dt>other</dt> +<dd><p>Another Obj.</p> +</dd> +</dl> +</dd> +<dt id="func_To_String">To_String</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>MatchAllQuery_To_String</strong>( + <span class="prefix">lucy_</span>MatchAllQuery *<strong>self</strong> +); +</code></pre> +<p>Generic stringification: âClassName@hex_mem_addressâ.</p> +</dd> +<dt id="func_Make_Compiler">Make_Compiler</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Compiler.html">Compiler</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>MatchAllQuery_Make_Compiler</strong>( + <span class="prefix">lucy_</span>MatchAllQuery *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Searcher.html">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>searcher</dt> +<dd><p>A Searcher.</p> +</dd> +<dt>boost</dt> +<dd><p>A scoring multiplier.</p> +</dd> +<dt>subordinate</dt> +<dd><p>Indicates whether the Query is a subquery (as +opposed to a top-level query). If false, the implementation must +invoke <a href="../../Lucy/Search/Compiler.html#func_Normalize">Normalize()</a> on the newly minted Compiler object before returning +it.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::MatchAllQuery is a <a href="../../Lucy/Search/Query.html">Lucy::Search::Query</a> is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Search/Matcher.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Search/Matcher.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Search/Matcher.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Search/Matcher.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,100 @@ +Title: Lucy::Search::Matcher â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::Matcher</h2> +<table> +<tr> +<td class="label">parcel</td> +<td><a href="../../lucy.html">Lucy</a></td> +</tr> +<tr> +<td class="label">class variable</td> +<td><code><span class="prefix">LUCY_</span>MATCHER</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>Matcher</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>Matcher</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/Matcher.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::Matcher â Match a set of document ids.</p> +<h3>Description</h3> +<p>A Matcher iterates over a set of ascending document ids. Some Matchers +implement <a href="../../Lucy/Search/Matcher.html#func_Score">Score()</a> and can assign relevance scores to the docs that they +match. Other implementations may be match-only.</p> +<h3>Functions</h3> +<dl> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>Matcher* +<span class="prefix">lucy_</span><strong>Matcher_init</strong>( + <span class="prefix">lucy_</span>Matcher *<strong>self</strong> +); +</code></pre> +<p>Abstract initializer.</p> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Next">Next <span class="comment">(abstract)</span></dt> +<dd> +<pre><code>int32_t +<span class="prefix">lucy_</span><strong>Matcher_Next</strong>( + <span class="prefix">lucy_</span>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 id="func_Advance">Advance</dt> +<dd> +<pre><code>int32_t +<span class="prefix">lucy_</span><strong>Matcher_Advance</strong>( + <span class="prefix">lucy_</span>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 <a href="../../Lucy/Search/Matcher.html#func_Next">Next()</a> +over and over, but subclasses have the option of doing something more +efficient.</p> +<dl> +<dt>target</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 id="func_Get_Doc_ID">Get_Doc_ID <span class="comment">(abstract)</span></dt> +<dd> +<pre><code>int32_t +<span class="prefix">lucy_</span><strong>Matcher_Get_Doc_ID</strong>( + <span class="prefix">lucy_</span>Matcher *<strong>self</strong> +); +</code></pre> +<p>Return the current doc id. Valid only after a successful call to +<a href="../../Lucy/Search/Matcher.html#func_Next">Next()</a> or <a href="../../Lucy/Search/Matcher.html#func_Advance">Advance()</a> and must not be called otherwise.</p> +</dd> +<dt id="func_Score">Score <span class="comment">(abstract)</span></dt> +<dd> +<pre><code>float +<span class="prefix">lucy_</span><strong>Matcher_Score</strong>( + <span class="prefix">lucy_</span>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 <a href="../../Lucy/Search/Matcher.html#func_Score">Score()</a>.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::Matcher is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Search/NOTQuery.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Search/NOTQuery.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Search/NOTQuery.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Search/NOTQuery.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,143 @@ +Title: Lucy::Search::NOTQuery â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::NOTQuery</h2> +<table> +<tr> +<td class="label">parcel</td> +<td><a href="../../lucy.html">Lucy</a></td> +</tr> +<tr> +<td class="label">class variable</td> +<td><code><span class="prefix">LUCY_</span>NOTQUERY</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>NOTQuery</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>NOTQuery</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/NOTQuery.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::NOTQuery â Invert the result set of another Query.</p> +<h3>Description</h3> +<p>A NOTQuery wraps another <a href="../../Lucy/Search/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/Search/ANDQuery.html">ANDQuery</a> to provide âa AND NOT bâ +semantics.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>NOTQuery* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>NOTQuery_new</strong>( + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>negated_query</strong> +); +</code></pre> +<p>Create a new NOTQuery.</p> +<dl> +<dt>negated_query</dt> +<dd><p>The Query whose result set should be inverted.</p> +</dd> +</dl> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>NOTQuery* +<span class="prefix">lucy_</span><strong>NOTQuery_init</strong>( + <span class="prefix">lucy_</span>NOTQuery *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>negated_query</strong> +); +</code></pre> +<p>Initialize a NOTQuery.</p> +<dl> +<dt>negated_query</dt> +<dd><p>The Query whose result set should be inverted.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Get_Negated_Query">Get_Negated_Query</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a>* +<span class="prefix">lucy_</span><strong>NOTQuery_Get_Negated_Query</strong>( + <span class="prefix">lucy_</span>NOTQuery *<strong>self</strong> +); +</code></pre> +<p>Accessor for the objectâs negated query.</p> +</dd> +<dt id="func_Set_Negated_Query">Set_Negated_Query</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>NOTQuery_Set_Negated_Query</strong>( + <span class="prefix">lucy_</span>NOTQuery *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>negated_query</strong> +); +</code></pre> +<p>Setter for the objectâs negated query.</p> +</dd> +<dt id="func_Make_Compiler">Make_Compiler</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Compiler.html">Compiler</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>NOTQuery_Make_Compiler</strong>( + <span class="prefix">lucy_</span>NOTQuery *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Searcher.html">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>searcher</dt> +<dd><p>A Searcher.</p> +</dd> +<dt>boost</dt> +<dd><p>A scoring multiplier.</p> +</dd> +<dt>subordinate</dt> +<dd><p>Indicates whether the Query is a subquery (as +opposed to a top-level query). If false, the implementation must +invoke <a href="../../Lucy/Search/Compiler.html#func_Normalize">Normalize()</a> on the newly minted Compiler object before returning +it.</p> +</dd> +</dl> +</dd> +<dt id="func_To_String">To_String</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>NOTQuery_To_String</strong>( + <span class="prefix">lucy_</span>NOTQuery *<strong>self</strong> +); +</code></pre> +<p>Generic stringification: âClassName@hex_mem_addressâ.</p> +</dd> +<dt id="func_Equals">Equals</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>NOTQuery_Equals</strong>( + <span class="prefix">lucy_</span>NOTQuery *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>other</strong> +); +</code></pre> +<p>Indicate whether two objects are the same. By default, compares the +memory address.</p> +<dl> +<dt>other</dt> +<dd><p>Another Obj.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::NOTQuery is a <a href="../../Lucy/Search/PolyQuery.html">Lucy::Search::PolyQuery</a> is a <a href="../../Lucy/Search/Query.html">Lucy::Search::Query</a> is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Search/NoMatchQuery.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Search/NoMatchQuery.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Search/NoMatchQuery.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Search/NoMatchQuery.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,126 @@ +Title: Lucy::Search::NoMatchQuery â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::NoMatchQuery</h2> +<table> +<tr> +<td class="label">parcel</td> +<td><a href="../../lucy.html">Lucy</a></td> +</tr> +<tr> +<td class="label">class variable</td> +<td><code><span class="prefix">LUCY_</span>NOMATCHQUERY</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>NoMatchQuery</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>NoMatchQuery</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/NoMatchQuery.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::NoMatchQuery â Query which matches no documents.</p> +<h3>Description</h3> +<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/Search/QueryParser.html">QueryParser</a> is asked to parse an empty +string.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>NoMatchQuery* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>NoMatchQuery_new</strong>(void); +</code></pre> +<p>Constructor. Takes no arguments.</p> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>NoMatchQuery* +<span class="prefix">lucy_</span><strong>NoMatchQuery_init</strong>( + <span class="prefix">lucy_</span>NoMatchQuery *<strong>self</strong> +); +</code></pre> +<p>Initialize a NoMatchQuery.</p> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Dump">Dump</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>NoMatchQuery_Dump</strong>( + <span class="prefix">lucy_</span>NoMatchQuery *<strong>self</strong> +); +</code></pre> +</dd> +<dt id="func_Load">Load</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>NoMatchQuery* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>NoMatchQuery_Load</strong>( + <span class="prefix">lucy_</span>NoMatchQuery *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>dump</strong> +); +</code></pre> +</dd> +<dt id="func_Equals">Equals</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>NoMatchQuery_Equals</strong>( + <span class="prefix">lucy_</span>NoMatchQuery *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>other</strong> +); +</code></pre> +<p>Indicate whether two objects are the same. By default, compares the +memory address.</p> +<dl> +<dt>other</dt> +<dd><p>Another Obj.</p> +</dd> +</dl> +</dd> +<dt id="func_To_String">To_String</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>NoMatchQuery_To_String</strong>( + <span class="prefix">lucy_</span>NoMatchQuery *<strong>self</strong> +); +</code></pre> +<p>Generic stringification: âClassName@hex_mem_addressâ.</p> +</dd> +<dt id="func_Make_Compiler">Make_Compiler</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Compiler.html">Compiler</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>NoMatchQuery_Make_Compiler</strong>( + <span class="prefix">lucy_</span>NoMatchQuery *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Searcher.html">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>searcher</dt> +<dd><p>A Searcher.</p> +</dd> +<dt>boost</dt> +<dd><p>A scoring multiplier.</p> +</dd> +<dt>subordinate</dt> +<dd><p>Indicates whether the Query is a subquery (as +opposed to a top-level query). If false, the implementation must +invoke <a href="../../Lucy/Search/Compiler.html#func_Normalize">Normalize()</a> on the newly minted Compiler object before returning +it.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::NoMatchQuery is a <a href="../../Lucy/Search/Query.html">Lucy::Search::Query</a> is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div>