Added: lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/MatchAllQuery.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/MatchAllQuery.mdtext?rev=1762636&view=auto ============================================================================== --- lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/MatchAllQuery.mdtext (added) +++ lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/MatchAllQuery.mdtext Wed Sep 28 12:06:24 2016 @@ -0,0 +1,148 @@ +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> +<h4>Methods inherited from Lucy::Search::Query</h4> +<dl> +<dt id="func_Set_Boost">Set_Boost</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>MatchAllQuery_Set_Boost</strong>( + <span class="prefix">lucy_</span>MatchAllQuery *<strong>self</strong>, + float <strong>boost</strong> +); +</code></pre> +<p>Set the Queryâs boost.</p> +</dd> +<dt id="func_Get_Boost">Get_Boost</dt> +<dd> +<pre><code>float +<span class="prefix">lucy_</span><strong>MatchAllQuery_Get_Boost</strong>( + <span class="prefix">lucy_</span>MatchAllQuery *<strong>self</strong> +); +</code></pre> +<p>Get the Queryâs boost.</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>MatchAllQuery_Dump</strong>( + <span class="prefix">lucy_</span>MatchAllQuery *<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>MatchAllQuery_Load</strong>( + <span class="prefix">lucy_</span>MatchAllQuery *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>dump</strong> +); +</code></pre> +</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/0.5.0/c/Lucy/Search/Matcher.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/Matcher.mdtext?rev=1762636&view=auto ============================================================================== --- lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/Matcher.mdtext (added) +++ lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/Matcher.mdtext Wed Sep 28 12:06:24 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/0.5.0/c/Lucy/Search/NOTQuery.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/NOTQuery.mdtext?rev=1762636&view=auto ============================================================================== --- lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/NOTQuery.mdtext (added) +++ lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/NOTQuery.mdtext Wed Sep 28 12:06:24 2016 @@ -0,0 +1,195 @@ +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> +<h4>Methods inherited from Lucy::Search::PolyQuery</h4> +<dl> +<dt id="func_Add_Child">Add_Child</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>NOTQuery_Add_Child</strong>( + <span class="prefix">lucy_</span>NOTQuery *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>query</strong> +); +</code></pre> +<p>Add a child Query node.</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>NOTQuery_Dump</strong>( + <span class="prefix">lucy_</span>NOTQuery *<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>NOTQuery_Load</strong>( + <span class="prefix">lucy_</span>NOTQuery *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>dump</strong> +); +</code></pre> +</dd> +</dl> +<h4>Methods inherited from Lucy::Search::Query</h4> +<dl> +<dt id="func_Set_Boost">Set_Boost</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>NOTQuery_Set_Boost</strong>( + <span class="prefix">lucy_</span>NOTQuery *<strong>self</strong>, + float <strong>boost</strong> +); +</code></pre> +<p>Set the Queryâs boost.</p> +</dd> +<dt id="func_Get_Boost">Get_Boost</dt> +<dd> +<pre><code>float +<span class="prefix">lucy_</span><strong>NOTQuery_Get_Boost</strong>( + <span class="prefix">lucy_</span>NOTQuery *<strong>self</strong> +); +</code></pre> +<p>Get the Queryâs boost.</p> +</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/0.5.0/c/Lucy/Search/NoMatchQuery.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/NoMatchQuery.mdtext?rev=1762636&view=auto ============================================================================== --- lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/NoMatchQuery.mdtext (added) +++ lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/NoMatchQuery.mdtext Wed Sep 28 12:06:24 2016 @@ -0,0 +1,148 @@ +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> +<h4>Methods inherited from Lucy::Search::Query</h4> +<dl> +<dt id="func_Set_Boost">Set_Boost</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>NoMatchQuery_Set_Boost</strong>( + <span class="prefix">lucy_</span>NoMatchQuery *<strong>self</strong>, + float <strong>boost</strong> +); +</code></pre> +<p>Set the Queryâs boost.</p> +</dd> +<dt id="func_Get_Boost">Get_Boost</dt> +<dd> +<pre><code>float +<span class="prefix">lucy_</span><strong>NoMatchQuery_Get_Boost</strong>( + <span class="prefix">lucy_</span>NoMatchQuery *<strong>self</strong> +); +</code></pre> +<p>Get the Queryâs boost.</p> +</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> Added: lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/ORQuery.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/ORQuery.mdtext?rev=1762636&view=auto ============================================================================== --- lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/ORQuery.mdtext (added) +++ lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/ORQuery.mdtext Wed Sep 28 12:06:24 2016 @@ -0,0 +1,174 @@ +Title: Lucy::Search::ORQuery â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::ORQuery</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>ORQUERY</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>ORQuery</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>ORQuery</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/ORQuery.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::ORQuery â Union multiple result sets.</p> +<h3>Description</h3> +<p>ORQuery is a composite <a href="../../Lucy/Search/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> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>ORQuery* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>ORQuery_new</strong>( + <span class="prefix">cfish_</span><a href="../../Clownfish/Vector.html">Vector</a> *<strong>children</strong> +); +</code></pre> +<p>Create a new ORQuery.</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>ORQuery* +<span class="prefix">lucy_</span><strong>ORQuery_init</strong>( + <span class="prefix">lucy_</span>ORQuery *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Vector.html">Vector</a> *<strong>children</strong> +); +</code></pre> +<p>Initialize an ORQuery.</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>ORQuery_Make_Compiler</strong>( + <span class="prefix">lucy_</span>ORQuery *<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>ORQuery_To_String</strong>( + <span class="prefix">lucy_</span>ORQuery *<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>ORQuery_Equals</strong>( + <span class="prefix">lucy_</span>ORQuery *<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> +<h4>Methods inherited from Lucy::Search::PolyQuery</h4> +<dl> +<dt id="func_Add_Child">Add_Child</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>ORQuery_Add_Child</strong>( + <span class="prefix">lucy_</span>ORQuery *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>query</strong> +); +</code></pre> +<p>Add a child Query node.</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>ORQuery_Dump</strong>( + <span class="prefix">lucy_</span>ORQuery *<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>ORQuery_Load</strong>( + <span class="prefix">lucy_</span>ORQuery *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>dump</strong> +); +</code></pre> +</dd> +</dl> +<h4>Methods inherited from Lucy::Search::Query</h4> +<dl> +<dt id="func_Set_Boost">Set_Boost</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>ORQuery_Set_Boost</strong>( + <span class="prefix">lucy_</span>ORQuery *<strong>self</strong>, + float <strong>boost</strong> +); +</code></pre> +<p>Set the Queryâs boost.</p> +</dd> +<dt id="func_Get_Boost">Get_Boost</dt> +<dd> +<pre><code>float +<span class="prefix">lucy_</span><strong>ORQuery_Get_Boost</strong>( + <span class="prefix">lucy_</span>ORQuery *<strong>self</strong> +); +</code></pre> +<p>Get the Queryâs boost.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::ORQuery 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/0.5.0/c/Lucy/Search/PhraseQuery.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/PhraseQuery.mdtext?rev=1762636&view=auto ============================================================================== --- lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/PhraseQuery.mdtext (added) +++ lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/PhraseQuery.mdtext Wed Sep 28 12:06:24 2016 @@ -0,0 +1,185 @@ +Title: Lucy::Search::PhraseQuery â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::PhraseQuery</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>PHRASEQUERY</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>PhraseQuery</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>PhraseQuery</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/PhraseQuery.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::PhraseQuery â Query matching an ordered list of terms.</p> +<h3>Description</h3> +<p>PhraseQuery is a subclass of <a href="../../Lucy/Search/Query.html">Query</a> for matching +against an ordered sequence of terms.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>PhraseQuery* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>PhraseQuery_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/Vector.html">Vector</a> *<strong>terms</strong> +); +</code></pre> +<p>Create a new PhraseQuery.</p> +<dl> +<dt>field</dt> +<dd><p>The field that the phrase must occur in.</p> +</dd> +<dt>terms</dt> +<dd><p>The ordered array of terms that must match.</p> +</dd> +</dl> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>PhraseQuery* +<span class="prefix">lucy_</span><strong>PhraseQuery_init</strong>( + <span class="prefix">lucy_</span>PhraseQuery *<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/Vector.html">Vector</a> *<strong>terms</strong> +); +</code></pre> +<p>Initialize a PhraseQuery.</p> +<dl> +<dt>field</dt> +<dd><p>The field that the phrase must occur in.</p> +</dd> +<dt>terms</dt> +<dd><p>The ordered array of terms that must match.</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>PhraseQuery_Get_Field</strong>( + <span class="prefix">lucy_</span>PhraseQuery *<strong>self</strong> +); +</code></pre> +<p>Accessor for objectâs field attribute.</p> +</dd> +<dt id="func_Get_Terms">Get_Terms</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/Vector.html">Vector</a>* +<span class="prefix">lucy_</span><strong>PhraseQuery_Get_Terms</strong>( + <span class="prefix">lucy_</span>PhraseQuery *<strong>self</strong> +); +</code></pre> +<p>Accessor for objectâs array of terms.</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>PhraseQuery_Make_Compiler</strong>( + <span class="prefix">lucy_</span>PhraseQuery *<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_Equals">Equals</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>PhraseQuery_Equals</strong>( + <span class="prefix">lucy_</span>PhraseQuery *<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>PhraseQuery_To_String</strong>( + <span class="prefix">lucy_</span>PhraseQuery *<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>PhraseQuery_Dump</strong>( + <span class="prefix">lucy_</span>PhraseQuery *<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>PhraseQuery_Load</strong>( + <span class="prefix">lucy_</span>PhraseQuery *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>dump</strong> +); +</code></pre> +</dd> +</dl> +<h4>Methods inherited from Lucy::Search::Query</h4> +<dl> +<dt id="func_Set_Boost">Set_Boost</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>PhraseQuery_Set_Boost</strong>( + <span class="prefix">lucy_</span>PhraseQuery *<strong>self</strong>, + float <strong>boost</strong> +); +</code></pre> +<p>Set the Queryâs boost.</p> +</dd> +<dt id="func_Get_Boost">Get_Boost</dt> +<dd> +<pre><code>float +<span class="prefix">lucy_</span><strong>PhraseQuery_Get_Boost</strong>( + <span class="prefix">lucy_</span>PhraseQuery *<strong>self</strong> +); +</code></pre> +<p>Get the Queryâs boost.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::PhraseQuery 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/0.5.0/c/Lucy/Search/PolyQuery.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/PolyQuery.mdtext?rev=1762636&view=auto ============================================================================== --- lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/PolyQuery.mdtext (added) +++ lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/PolyQuery.mdtext Wed Sep 28 12:06:24 2016 @@ -0,0 +1,133 @@ +Title: Lucy::Search::PolyQuery â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::PolyQuery</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>POLYQUERY</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>PolyQuery</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>PolyQuery</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/PolyQuery.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::PolyQuery â Base class for composite Query objects.</p> +<h3>Description</h3> +<p>PolyQuery serves as a shared base class for +<a href="../../Lucy/Search/ANDQuery.html">ANDQuery</a>, +<a href="../../Lucy/Search/ORQuery.html">ORQuery</a>, +<a href="../../Lucy/Search/NOTQuery.html">NOTQuery</a>, and +<a href="../../Lucy/Search/RequiredOptionalQuery.html">RequiredOptionalQuery</a>. All of +these classes may serve as nodes in composite Query with a tree structure +which may be walked.</p> +<h3>Methods</h3> +<dl> +<dt id="func_Add_Child">Add_Child</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>PolyQuery_Add_Child</strong>( + <span class="prefix">lucy_</span>PolyQuery *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>query</strong> +); +</code></pre> +<p>Add a child Query node.</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>PolyQuery_Dump</strong>( + <span class="prefix">lucy_</span>PolyQuery *<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>PolyQuery_Load</strong>( + <span class="prefix">lucy_</span>PolyQuery *<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>PolyQuery_Equals</strong>( + <span class="prefix">lucy_</span>PolyQuery *<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> +<h4>Methods inherited from Lucy::Search::Query</h4> +<dl> +<dt id="func_Make_Compiler">Make_Compiler <span class="comment">(abstract)</span></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>PolyQuery_Make_Compiler</strong>( + <span class="prefix">lucy_</span>PolyQuery *<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_Set_Boost">Set_Boost</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>PolyQuery_Set_Boost</strong>( + <span class="prefix">lucy_</span>PolyQuery *<strong>self</strong>, + float <strong>boost</strong> +); +</code></pre> +<p>Set the Queryâs boost.</p> +</dd> +<dt id="func_Get_Boost">Get_Boost</dt> +<dd> +<pre><code>float +<span class="prefix">lucy_</span><strong>PolyQuery_Get_Boost</strong>( + <span class="prefix">lucy_</span>PolyQuery *<strong>self</strong> +); +</code></pre> +<p>Get the Queryâs boost.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::PolyQuery 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/0.5.0/c/Lucy/Search/PolySearcher.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/PolySearcher.mdtext?rev=1762636&view=auto ============================================================================== --- lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/PolySearcher.mdtext (added) +++ lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/PolySearcher.mdtext Wed Sep 28 12:06:24 2016 @@ -0,0 +1,200 @@ +Title: Lucy::Search::PolySearcher â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::PolySearcher</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>POLYSEARCHER</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>PolySearcher</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>PolySearcher</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/PolySearcher.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::PolySearcher â Aggregate results from multiple Searchers.</p> +<h3>Description</h3> +<p>The primary use for PolySearcher is to aggregate results from several +indexes on a single machine.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>PolySearcher* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>PolySearcher_new</strong>( + <span class="prefix">lucy_</span><a href="../../Lucy/Plan/Schema.html">Schema</a> *<strong>schema</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Vector.html">Vector</a> *<strong>searchers</strong> +); +</code></pre> +<p>Create a new PolySearcher.</p> +<dl> +<dt>schema</dt> +<dd><p>A Schema.</p> +</dd> +<dt>searchers</dt> +<dd><p>An array of Searchers.</p> +</dd> +</dl> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>PolySearcher* +<span class="prefix">lucy_</span><strong>PolySearcher_init</strong>( + <span class="prefix">lucy_</span>PolySearcher *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Plan/Schema.html">Schema</a> *<strong>schema</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Vector.html">Vector</a> *<strong>searchers</strong> +); +</code></pre> +<p>Initialize a PolySearcher.</p> +<dl> +<dt>schema</dt> +<dd><p>A Schema.</p> +</dd> +<dt>searchers</dt> +<dd><p>An array of Searchers.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Doc_Max">Doc_Max</dt> +<dd> +<pre><code>int32_t +<span class="prefix">lucy_</span><strong>PolySearcher_Doc_Max</strong>( + <span class="prefix">lucy_</span>PolySearcher *<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>PolySearcher_Doc_Freq</strong>( + <span class="prefix">lucy_</span>PolySearcher *<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>PolySearcher_Collect</strong>( + <span class="prefix">lucy_</span>PolySearcher *<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>PolySearcher_Fetch_Doc</strong>( + <span class="prefix">lucy_</span>PolySearcher *<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> +</dl> +<h4>Methods inherited from Lucy::Search::Searcher</h4> +<dl> +<dt id="func_Glean_Query">Glean_Query</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>PolySearcher_Glean_Query</strong>( + <span class="prefix">lucy_</span>PolySearcher *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">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 id="func_Hits">Hits</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Hits.html">Hits</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>PolySearcher_Hits</strong>( + <span class="prefix">lucy_</span>PolySearcher *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>query</strong>, + uint32_t <strong>offset</strong>, + uint32_t <strong>num_wanted</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/SortSpec.html">SortSpec</a> *<strong>sort_spec</strong> +); +</code></pre> +<p>Return a Hits object containing the top results.</p> +<dl> +<dt>query</dt> +<dd><p>Either a Query object or a query string.</p> +</dd> +<dt>offset</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>num_wanted</dt> +<dd><p>The number of hits you would like to see after +<code>offset</code> is taken into account.</p> +</dd> +<dt>sort_spec</dt> +<dd><p>A <a href="../../Lucy/Search/SortSpec.html">SortSpec</a>, which will affect +how results are ranked and returned.</p> +</dd> +</dl> +</dd> +<dt id="func_Get_Schema">Get_Schema</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Plan/Schema.html">Schema</a>* +<span class="prefix">lucy_</span><strong>PolySearcher_Get_Schema</strong>( + <span class="prefix">lucy_</span>PolySearcher *<strong>self</strong> +); +</code></pre> +<p>Accessor for the objectâs <code>schema</code> member.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::PolySearcher 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/0.5.0/c/Lucy/Search/Query.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/Query.mdtext?rev=1762636&view=auto ============================================================================== --- lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/Query.mdtext (added) +++ lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/Query.mdtext Wed Sep 28 12:06:24 2016 @@ -0,0 +1,130 @@ +Title: Lucy::Search::Query â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::Query</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>QUERY</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>Query</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>Query</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/Query.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::Query â A specification for a search query.</p> +<h3>Description</h3> +<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/Search/QueryParser.html">QueryParserâs</a> +<a href="../../Lucy/Search/QueryParser.html#func_Parse">Parse()</a> method, which outputs an abstract syntax tree built up from various +Query subclasses such as <a href="../../Lucy/Search/ANDQuery.html">ANDQuery</a> and +<a href="../../Lucy/Search/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 <a href="../../Lucy/Search/Query.html#func_Make_Compiler">Make_Compiler()</a>, which is the first step +in compiling a Query down to a <a href="../../Lucy/Search/Matcher.html">Matcher</a> which +can actually match and score documents.</p> +<h3>Functions</h3> +<dl> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>Query* +<span class="prefix">lucy_</span><strong>Query_init</strong>( + <span class="prefix">lucy_</span>Query *<strong>self</strong>, + float <strong>boost</strong> +); +</code></pre> +<p>Abstract initializer.</p> +<dl> +<dt>boost</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> +<h3>Methods</h3> +<dl> +<dt id="func_Make_Compiler">Make_Compiler <span class="comment">(abstract)</span></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>Query_Make_Compiler</strong>( + <span class="prefix">lucy_</span>Query *<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_Set_Boost">Set_Boost</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Query_Set_Boost</strong>( + <span class="prefix">lucy_</span>Query *<strong>self</strong>, + float <strong>boost</strong> +); +</code></pre> +<p>Set the Queryâs boost.</p> +</dd> +<dt id="func_Get_Boost">Get_Boost</dt> +<dd> +<pre><code>float +<span class="prefix">lucy_</span><strong>Query_Get_Boost</strong>( + <span class="prefix">lucy_</span>Query *<strong>self</strong> +); +</code></pre> +<p>Get the Queryâs boost.</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>Query_Dump</strong>( + <span class="prefix">lucy_</span>Query *<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>Query_Load</strong>( + <span class="prefix">lucy_</span>Query *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>dump</strong> +); +</code></pre> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::Query is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/QueryParser.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/QueryParser.mdtext?rev=1762636&view=auto ============================================================================== --- lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/QueryParser.mdtext (added) +++ lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/QueryParser.mdtext Wed Sep 28 12:06:24 2016 @@ -0,0 +1,357 @@ +Title: Lucy::Search::QueryParser â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::QueryParser</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>QUERYPARSER</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>QueryParser</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>QParser</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/QueryParser.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::QueryParser â Transform a string into a Query object.</p> +<h3>Description</h3> +<p>QueryParser accepts search strings as input and produces +<a href="../../Lucy/Search/Query.html">Query</a> objects, suitable for feeding into +<a href="../../Lucy/Search/IndexSearcher.html">IndexSearcher</a> and other +<a href="../../Lucy/Search/Searcher.html">Searcher</a> subclasses.</p> +<p>The following syntactical constructs are recognized by QueryParser:</p> +<ul> +<li>Boolean operators âANDâ, âORâ, and âAND NOTâ.</li> +<li>Prepented +plus and -minus, indicating that the labeled entity +should be either required or forbidden â be it a single word, a +phrase, or a parenthetical group.</li> +<li>Logical groups, delimited by parentheses.</li> +<li>Phrases, delimited by double quotes.</li> +</ul> +<p>Additionally, the following syntax can be enabled via <a href="../../Lucy/Search/QueryParser.html#func_Set_Heed_Colons">Set_Heed_Colons()</a>:</p> +<ul> +<li>Field-specific constructs, in the form of âfieldname:termtextâ or +âfieldname:(foo bar)â. (The field specified by âfieldname:â will be +used instead of the QueryParserâs default fields).</li> +</ul> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>QueryParser* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>QParser_new</strong>( + <span class="prefix">lucy_</span><a href="../../Lucy/Plan/Schema.html">Schema</a> *<strong>schema</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Analysis/Analyzer.html">Analyzer</a> *<strong>analyzer</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>default_boolop</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Vector.html">Vector</a> *<strong>fields</strong> +); +</code></pre> +<p>Constructor.</p> +<dl> +<dt>schema</dt> +<dd><p>A <a href="../../Lucy/Plan/Schema.html">Schema</a>.</p> +</dd> +<dt>analyzer</dt> +<dd><p>An <a href="../../Lucy/Analysis/Analyzer.html">Analyzer</a>. +Ordinarily, the analyzers specified by each fieldâs definition will be +used, but if <code>analyzer</code> is supplied, it will override and be used for +all fields. This can lead to mismatches between what is in the index +and what is being searched for, so use caution.</p> +</dd> +<dt>fields</dt> +<dd><p>The names of the fields which will be searched against. +Defaults to those fields which are defined as indexed in the supplied +Schema.</p> +</dd> +<dt>default_boolop</dt> +<dd><p>Two possible values: âANDâ and âORâ. The default +is âORâ, which means: return documents which match any of the query +terms. If you want only documents which match all of the query terms, +set this to âANDâ.</p> +</dd> +</dl> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>QueryParser* +<span class="prefix">lucy_</span><strong>QParser_init</strong>( + <span class="prefix">lucy_</span>QueryParser *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Plan/Schema.html">Schema</a> *<strong>schema</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Analysis/Analyzer.html">Analyzer</a> *<strong>analyzer</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>default_boolop</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Vector.html">Vector</a> *<strong>fields</strong> +); +</code></pre> +<p>Initialize a QueryParser.</p> +<dl> +<dt>schema</dt> +<dd><p>A <a href="../../Lucy/Plan/Schema.html">Schema</a>.</p> +</dd> +<dt>analyzer</dt> +<dd><p>An <a href="../../Lucy/Analysis/Analyzer.html">Analyzer</a>. +Ordinarily, the analyzers specified by each fieldâs definition will be +used, but if <code>analyzer</code> is supplied, it will override and be used for +all fields. This can lead to mismatches between what is in the index +and what is being searched for, so use caution.</p> +</dd> +<dt>fields</dt> +<dd><p>The names of the fields which will be searched against. +Defaults to those fields which are defined as indexed in the supplied +Schema.</p> +</dd> +<dt>default_boolop</dt> +<dd><p>Two possible values: âANDâ and âORâ. The default +is âORâ, which means: return documents which match any of the query +terms. If you want only documents which match all of the query terms, +set this to âANDâ.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Parse">Parse</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>QParser_Parse</strong>( + <span class="prefix">lucy_</span>QueryParser *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>query_string</strong> +); +</code></pre> +<p>Build a Query object from the contents of a query string. At present, +implemented internally by calling <a href="../../Lucy/Search/QueryParser.html#func_Tree">Tree()</a>, <a href="../../Lucy/Search/QueryParser.html#func_Expand">Expand()</a>, and <a href="../../Lucy/Search/QueryParser.html#func_Prune">Prune()</a>.</p> +<dl> +<dt>query_string</dt> +<dd><p>The string to be parsed. May be NULL.</p> +</dd> +</dl> +<p><strong>Returns:</strong> a Query.</p> +</dd> +<dt id="func_Tree">Tree</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>QParser_Tree</strong>( + <span class="prefix">lucy_</span>QueryParser *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>query_string</strong> +); +</code></pre> +<p>Parse the logical structure of a query string, building a tree +comprised of Query objects. Leaf nodes in the tree will most often be +LeafQuery objects but might be MatchAllQuery or NoMatchQuery objects as +well. Internal nodes will be objects which subclass PolyQuery: +ANDQuery, ORQuery, NOTQuery, and RequiredOptionalQuery.</p> +<p>The output of <a href="../../Lucy/Search/QueryParser.html#func_Tree">Tree()</a> is an intermediate form which must be passed +through <a href="../../Lucy/Search/QueryParser.html#func_Expand">Expand()</a> before being used to feed a search.</p> +<dl> +<dt>query_string</dt> +<dd><p>The string to be parsed.</p> +</dd> +</dl> +<p><strong>Returns:</strong> a Query.</p> +</dd> +<dt id="func_Expand">Expand</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>QParser_Expand</strong>( + <span class="prefix">lucy_</span>QueryParser *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>query</strong> +); +</code></pre> +<p>Walk the hierarchy of a Query tree, descending through all PolyQuery +nodes and calling <a href="../../Lucy/Search/QueryParser.html#func_Expand_Leaf">Expand_Leaf()</a> on any LeafQuery nodes encountered.</p> +<dl> +<dt>query</dt> +<dd><p>A Query object.</p> +</dd> +</dl> +<p><strong>Returns:</strong> A Query â usually the same one that was supplied after +in-place modification, but possibly another.</p> +</dd> +<dt id="func_Expand_Leaf">Expand_Leaf</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>QParser_Expand_Leaf</strong>( + <span class="prefix">lucy_</span>QueryParser *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>query</strong> +); +</code></pre> +<p>Convert a LeafQuery into either a TermQuery, a PhraseQuery, or an +ORQuery joining multiple TermQueries/PhraseQueries to accommodate +multiple fields. LeafQuery text will be passed through the relevant +Analyzer for each field. Quoted text will be transformed into +PhraseQuery objects. Unquoted text will be converted to either a +TermQuery or a PhraseQuery depending on how many tokens are generated.</p> +<dl> +<dt>query</dt> +<dd><p>A Query. Only LeafQuery objects will be processed; others +will be passed through.</p> +</dd> +</dl> +<p><strong>Returns:</strong> A Query.</p> +</dd> +<dt id="func_Prune">Prune</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>QParser_Prune</strong>( + <span class="prefix">lucy_</span>QueryParser *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>query</strong> +); +</code></pre> +<p>Prevent certain Query structures from returning too many results. +Query objects built via <a href="../../Lucy/Search/QueryParser.html#func_Tree">Tree()</a> and <a href="../../Lucy/Search/QueryParser.html#func_Expand">Expand()</a> can generate âreturn the +worldâ result sets, such as in the case of +<code>NOT a_term_not_in_the_index</code>; <a href="../../Lucy/Search/QueryParser.html#func_Prune">Prune()</a> walks the hierarchy +and eliminates such branches.</p> +<pre><code> 'NOT foo' => [NOMATCH] + 'foo OR NOT bar' => 'foo' + 'foo OR (-bar AND -baz) => 'foo' +</code></pre> +<p><a href="../../Lucy/Search/QueryParser.html#func_Prune">Prune()</a> also eliminates some double-negative constructs â even though +such constructs may not actually return the world:</p> +<pre><code> 'foo AND -(-bar)' => 'foo' +</code></pre> +<p>In this example, safety is taking precedence over logical consistency. +If you want logical consistency instead, call <a href="../../Lucy/Search/QueryParser.html#func_Tree">Tree()</a> then <a href="../../Lucy/Search/QueryParser.html#func_Expand">Expand()</a>, +skipping <a href="../../Lucy/Search/QueryParser.html#func_Prune">Prune()</a>.</p> +<dl> +<dt>query</dt> +<dd><p>A Query.</p> +</dd> +</dl> +<p><strong>Returns:</strong> a Query; in most cases, the supplied Query after in-place +modification.</p> +</dd> +<dt id="func_Make_Term_Query">Make_Term_Query</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>QParser_Make_Term_Query</strong>( + <span class="prefix">lucy_</span>QueryParser *<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>Factory method creating a TermQuery.</p> +<dl> +<dt>field</dt> +<dd><p>Field name.</p> +</dd> +<dt>term</dt> +<dd><p>Term text.</p> +</dd> +</dl> +<p><strong>Returns:</strong> A Query.</p> +</dd> +<dt id="func_Make_Phrase_Query">Make_Phrase_Query</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>QParser_Make_Phrase_Query</strong>( + <span class="prefix">lucy_</span>QueryParser *<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/Vector.html">Vector</a> *<strong>terms</strong> +); +</code></pre> +<p>Factory method creating a PhraseQuery.</p> +<dl> +<dt>field</dt> +<dd><p>Field that the phrase must occur in.</p> +</dd> +<dt>terms</dt> +<dd><p>Ordered array of terms that must match.</p> +</dd> +</dl> +<p><strong>Returns:</strong> A Query.</p> +</dd> +<dt id="func_Make_OR_Query">Make_OR_Query</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>QParser_Make_OR_Query</strong>( + <span class="prefix">lucy_</span>QueryParser *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Vector.html">Vector</a> *<strong>children</strong> +); +</code></pre> +<p>Factory method creating an ORQuery.</p> +<dl> +<dt>children</dt> +<dd><p>Array of child Queries.</p> +</dd> +</dl> +<p><strong>Returns:</strong> A Query.</p> +</dd> +<dt id="func_Make_AND_Query">Make_AND_Query</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>QParser_Make_AND_Query</strong>( + <span class="prefix">lucy_</span>QueryParser *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Vector.html">Vector</a> *<strong>children</strong> +); +</code></pre> +<p>Factory method creating an ANDQuery.</p> +<dl> +<dt>children</dt> +<dd><p>Array of child Queries.</p> +</dd> +</dl> +<p><strong>Returns:</strong> A Query.</p> +</dd> +<dt id="func_Make_NOT_Query">Make_NOT_Query</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>QParser_Make_NOT_Query</strong>( + <span class="prefix">lucy_</span>QueryParser *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>negated_query</strong> +); +</code></pre> +<p>Factory method creating a NOTQuery.</p> +<dl> +<dt>negated_query</dt> +<dd><p>Query to be inverted.</p> +</dd> +</dl> +<p><strong>Returns:</strong> A Query.</p> +</dd> +<dt id="func_Make_Req_Opt_Query">Make_Req_Opt_Query</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>QParser_Make_Req_Opt_Query</strong>( + <span class="prefix">lucy_</span>QueryParser *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>required_query</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>optional_query</strong> +); +</code></pre> +<p>Factory method creating a RequiredOptionalQuery.</p> +<dl> +<dt>required_query</dt> +<dd><p>Query must must match.</p> +</dd> +<dt>optional_query</dt> +<dd><p>Query which should match.</p> +</dd> +</dl> +<p><strong>Returns:</strong> A Query.</p> +</dd> +<dt id="func_Set_Heed_Colons">Set_Heed_Colons</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>QParser_Set_Heed_Colons</strong>( + <span class="prefix">lucy_</span>QueryParser *<strong>self</strong>, + bool <strong>heed_colons</strong> +); +</code></pre> +<p>Enable/disable parsing of <code>fieldname:foo</code> constructs.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::QueryParser is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/RangeQuery.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/RangeQuery.mdtext?rev=1762636&view=auto ============================================================================== --- lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/RangeQuery.mdtext (added) +++ lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/RangeQuery.mdtext Wed Sep 28 12:06:24 2016 @@ -0,0 +1,181 @@ +Title: Lucy::Search::RangeQuery â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::RangeQuery</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>RANGEQUERY</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>RangeQuery</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>RangeQuery</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/RangeQuery.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::RangeQuery â Match a range of values.</p> +<h3>Description</h3> +<p>RangeQuery matches documents where the value for a particular field falls +within a given range.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>RangeQuery* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>RangeQuery_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/Obj.html">Obj</a> *<strong>lower_term</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>upper_term</strong>, + bool <strong>include_lower</strong>, + bool <strong>include_upper</strong> +); +</code></pre> +<p>Create a new RangeQuery.</p> +<p>Takes 5 parameters; <code>field</code> is required, as is at least one of either +<code>lower_term</code> or <code>upper_term</code>.</p> +<dl> +<dt>field</dt> +<dd><p>The name of a <code>sortable</code> field.</p> +</dd> +<dt>lower_term</dt> +<dd><p>Lower delimiter. If not supplied, all values +less than <code>upper_term</code> will pass.</p> +</dd> +<dt>upper_term</dt> +<dd><p>Upper delimiter. If not supplied, all values greater +than <code>lower_term</code> will pass.</p> +</dd> +<dt>include_lower</dt> +<dd><p>Indicates whether docs which match +<code>lower_term</code> should be included in the results.</p> +</dd> +<dt>include_upper</dt> +<dd><p>Indicates whether docs which match +<code>upper_term</code> should be included in the results.</p> +</dd> +</dl> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>RangeQuery* +<span class="prefix">lucy_</span><strong>RangeQuery_init</strong>( + <span class="prefix">lucy_</span>RangeQuery *<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>lower_term</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>upper_term</strong>, + bool <strong>include_lower</strong>, + bool <strong>include_upper</strong> +); +</code></pre> +<p>Initialize a RangeQuery. See <a href="../../Lucy/Search/RangeQuery.html#func_new">new()</a> for a description of the +parameters.</p> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Equals">Equals</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>RangeQuery_Equals</strong>( + <span class="prefix">lucy_</span>RangeQuery *<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>RangeQuery_To_String</strong>( + <span class="prefix">lucy_</span>RangeQuery *<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>RangeQuery_Make_Compiler</strong>( + <span class="prefix">lucy_</span>RangeQuery *<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_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>RangeQuery_Dump</strong>( + <span class="prefix">lucy_</span>RangeQuery *<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>RangeQuery_Load</strong>( + <span class="prefix">lucy_</span>RangeQuery *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>dump</strong> +); +</code></pre> +</dd> +</dl> +<h4>Methods inherited from Lucy::Search::Query</h4> +<dl> +<dt id="func_Set_Boost">Set_Boost</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>RangeQuery_Set_Boost</strong>( + <span class="prefix">lucy_</span>RangeQuery *<strong>self</strong>, + float <strong>boost</strong> +); +</code></pre> +<p>Set the Queryâs boost.</p> +</dd> +<dt id="func_Get_Boost">Get_Boost</dt> +<dd> +<pre><code>float +<span class="prefix">lucy_</span><strong>RangeQuery_Get_Boost</strong>( + <span class="prefix">lucy_</span>RangeQuery *<strong>self</strong> +); +</code></pre> +<p>Get the Queryâs boost.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::RangeQuery 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/0.5.0/c/Lucy/Search/RequiredOptionalQuery.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/RequiredOptionalQuery.mdtext?rev=1762636&view=auto ============================================================================== --- lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/RequiredOptionalQuery.mdtext (added) +++ lucy/site/trunk/content/docs/0.5.0/c/Lucy/Search/RequiredOptionalQuery.mdtext Wed Sep 28 12:06:24 2016 @@ -0,0 +1,219 @@ +Title: Lucy::Search::RequiredOptionalQuery â C API Documentation + +<div class="c-api"> +<h2>Lucy::Search::RequiredOptionalQuery</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>REQUIREDOPTIONALQUERY</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>RequiredOptionalQuery</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>ReqOptQuery</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Search/RequiredOptionalQuery.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Search::RequiredOptionalQuery â Join results for two Queries, one required, one optional.</p> +<h3>Description</h3> +<p>RequiredOptionalQuery joins the result sets of one Query which MUST match, +and one Query which SHOULD match. When only the required Query matches, +its score is passed along; when both match, the scores are summed.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>RequiredOptionalQuery* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>ReqOptQuery_new</strong>( + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>required_query</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>optional_query</strong> +); +</code></pre> +<p>Create a new RequiredOptionalQuery.</p> +<dl> +<dt>required_query</dt> +<dd><p>Query must must match.</p> +</dd> +<dt>optional_query</dt> +<dd><p>Query which should match.</p> +</dd> +</dl> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>RequiredOptionalQuery* +<span class="prefix">lucy_</span><strong>ReqOptQuery_init</strong>( + <span class="prefix">lucy_</span>RequiredOptionalQuery *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>required_query</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>optional_query</strong> +); +</code></pre> +<p>Initialize a RequiredOptionalQuery.</p> +<dl> +<dt>required_query</dt> +<dd><p>Query must must match.</p> +</dd> +<dt>optional_query</dt> +<dd><p>Query which should match.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Get_Required_Query">Get_Required_Query</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a>* +<span class="prefix">lucy_</span><strong>ReqOptQuery_Get_Required_Query</strong>( + <span class="prefix">lucy_</span>RequiredOptionalQuery *<strong>self</strong> +); +</code></pre> +<p>Getter for the required Query.</p> +</dd> +<dt id="func_Set_Required_Query">Set_Required_Query</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>ReqOptQuery_Set_Required_Query</strong>( + <span class="prefix">lucy_</span>RequiredOptionalQuery *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>required_query</strong> +); +</code></pre> +<p>Setter for the required Query.</p> +</dd> +<dt id="func_Get_Optional_Query">Get_Optional_Query</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a>* +<span class="prefix">lucy_</span><strong>ReqOptQuery_Get_Optional_Query</strong>( + <span class="prefix">lucy_</span>RequiredOptionalQuery *<strong>self</strong> +); +</code></pre> +<p>Getter for the optional Query.</p> +</dd> +<dt id="func_Set_Optional_Query">Set_Optional_Query</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>ReqOptQuery_Set_Optional_Query</strong>( + <span class="prefix">lucy_</span>RequiredOptionalQuery *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>optional_query</strong> +); +</code></pre> +<p>Setter for the optional 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>ReqOptQuery_Make_Compiler</strong>( + <span class="prefix">lucy_</span>RequiredOptionalQuery *<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>ReqOptQuery_To_String</strong>( + <span class="prefix">lucy_</span>RequiredOptionalQuery *<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>ReqOptQuery_Equals</strong>( + <span class="prefix">lucy_</span>RequiredOptionalQuery *<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> +<h4>Methods inherited from Lucy::Search::PolyQuery</h4> +<dl> +<dt id="func_Add_Child">Add_Child</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>ReqOptQuery_Add_Child</strong>( + <span class="prefix">lucy_</span>RequiredOptionalQuery *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>query</strong> +); +</code></pre> +<p>Add a child Query node.</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>ReqOptQuery_Dump</strong>( + <span class="prefix">lucy_</span>RequiredOptionalQuery *<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>ReqOptQuery_Load</strong>( + <span class="prefix">lucy_</span>RequiredOptionalQuery *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>dump</strong> +); +</code></pre> +</dd> +</dl> +<h4>Methods inherited from Lucy::Search::Query</h4> +<dl> +<dt id="func_Set_Boost">Set_Boost</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>ReqOptQuery_Set_Boost</strong>( + <span class="prefix">lucy_</span>RequiredOptionalQuery *<strong>self</strong>, + float <strong>boost</strong> +); +</code></pre> +<p>Set the Queryâs boost.</p> +</dd> +<dt id="func_Get_Boost">Get_Boost</dt> +<dd> +<pre><code>float +<span class="prefix">lucy_</span><strong>ReqOptQuery_Get_Boost</strong>( + <span class="prefix">lucy_</span>RequiredOptionalQuery *<strong>self</strong> +); +</code></pre> +<p>Get the Queryâs boost.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Search::RequiredOptionalQuery 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>