Added: lucy/site/trunk/content/docs/c/Lucy/Index/IndexManager.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Index/IndexManager.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Index/IndexManager.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Index/IndexManager.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,201 @@ +Title: Lucy::Index::IndexManager â C API Documentation + +<div class="c-api"> +<h2>Lucy::Index::IndexManager</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>INDEXMANAGER</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>IndexManager</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>IxManager</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Index/IndexManager.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Index::IndexManager â Policies governing index updating, locking, and file deletion.</p> +<h3>Description</h3> +<p>IndexManager is an advanced-use class for controlling index locking, +updating, merging, and deletion behaviors.</p> +<p>IndexManager and <a href="../../Lucy/Plan/Architecture.html">Architecture</a> are +complementary classes: Architecture is used to define traits and behaviors +which cannot change for the life of an index; IndexManager is used for +defining rules which may change from process to process.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>IndexManager* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>IxManager_new</strong>( + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>host</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Store/LockFactory.html">LockFactory</a> *<strong>lock_factory</strong> +); +</code></pre> +<p>Create a new IndexManager.</p> +<dl> +<dt>host</dt> +<dd><p>An identifier which should be unique per-machine.</p> +</dd> +<dt>lock_factory</dt> +<dd><p>A LockFactory.</p> +</dd> +</dl> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>IndexManager* +<span class="prefix">lucy_</span><strong>IxManager_init</strong>( + <span class="prefix">lucy_</span>IndexManager *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>host</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Store/LockFactory.html">LockFactory</a> *<strong>lock_factory</strong> +); +</code></pre> +<p>Initialize an IndexManager.</p> +<dl> +<dt>host</dt> +<dd><p>An identifier which should be unique per-machine.</p> +</dd> +<dt>lock_factory</dt> +<dd><p>A LockFactory.</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>IxManager_Destroy</strong>( + <span class="prefix">lucy_</span>IndexManager *<strong>self</strong> +); +</code></pre> +<p>Generic destructor. Frees the struct itself but not any complex +member elements.</p> +</dd> +<dt id="func_Set_Folder">Set_Folder</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>IxManager_Set_Folder</strong>( + <span class="prefix">lucy_</span>IndexManager *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Store/Folder.html">Folder</a> *<strong>folder</strong> +); +</code></pre> +<p>Setter for <code>folder</code> member. Typical clients (Indexer, +IndexReader) will use this method to install their own Folder instance.</p> +</dd> +<dt id="func_Get_Folder">Get_Folder</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Store/Folder.html">Folder</a>* +<span class="prefix">lucy_</span><strong>IxManager_Get_Folder</strong>( + <span class="prefix">lucy_</span>IndexManager *<strong>self</strong> +); +</code></pre> +<p>Getter for <code>folder</code> member.</p> +</dd> +<dt id="func_Get_Host">Get_Host</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a>* +<span class="prefix">lucy_</span><strong>IxManager_Get_Host</strong>( + <span class="prefix">lucy_</span>IndexManager *<strong>self</strong> +); +</code></pre> +<p>Getter for <code>host</code> member.</p> +</dd> +<dt id="func_Recycle">Recycle</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>IxManager_Recycle</strong>( + <span class="prefix">lucy_</span>IndexManager *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/PolyReader.html">PolyReader</a> *<strong>reader</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/DeletionsWriter.html">DeletionsWriter</a> *<strong>del_writer</strong>, + int64_t <strong>cutoff</strong>, + bool <strong>optimize</strong> +); +</code></pre> +<p>Return an array of SegReaders representing segments that should be +consolidated. Implementations must balance index-time churn against +search-time degradation due to segment proliferation. The default +implementation prefers small segments or segments with a high +proportion of deletions.</p> +<dl> +<dt>reader</dt> +<dd><p>A PolyReader.</p> +</dd> +<dt>del_writer</dt> +<dd><p>A DeletionsWriter.</p> +</dd> +<dt>cutoff</dt> +<dd><p>A segment number which all returned SegReaders must +exceed.</p> +</dd> +<dt>optimize</dt> +<dd><p>A boolean indicating whether to spend extra time +optimizing the index for search-time performance.</p> +</dd> +</dl> +</dd> +<dt id="func_Make_Write_Lock">Make_Write_Lock</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Store/Lock.html">Lock</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>IxManager_Make_Write_Lock</strong>( + <span class="prefix">lucy_</span>IndexManager *<strong>self</strong> +); +</code></pre> +<p>Create the Lock which controls access to modifying the logical content +of the index.</p> +</dd> +<dt id="func_Set_Write_Lock_Timeout">Set_Write_Lock_Timeout</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>IxManager_Set_Write_Lock_Timeout</strong>( + <span class="prefix">lucy_</span>IndexManager *<strong>self</strong>, + uint32_t <strong>timeout</strong> +); +</code></pre> +<p>Setter for write lock timeout. Default: 1000 milliseconds.</p> +</dd> +<dt id="func_Get_Write_Lock_Timeout">Get_Write_Lock_Timeout</dt> +<dd> +<pre><code>uint32_t +<span class="prefix">lucy_</span><strong>IxManager_Get_Write_Lock_Timeout</strong>( + <span class="prefix">lucy_</span>IndexManager *<strong>self</strong> +); +</code></pre> +<p>Getter for write lock timeout.</p> +</dd> +<dt id="func_Set_Write_Lock_Interval">Set_Write_Lock_Interval</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>IxManager_Set_Write_Lock_Interval</strong>( + <span class="prefix">lucy_</span>IndexManager *<strong>self</strong>, + uint32_t <strong>timeout</strong> +); +</code></pre> +<p>Setter for write lock retry interval. Default: 100 milliseconds.</p> +</dd> +<dt id="func_Get_Write_Lock_Interval">Get_Write_Lock_Interval</dt> +<dd> +<pre><code>uint32_t +<span class="prefix">lucy_</span><strong>IxManager_Get_Write_Lock_Interval</strong>( + <span class="prefix">lucy_</span>IndexManager *<strong>self</strong> +); +</code></pre> +<p>Getter for write lock retry interval.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Index::IndexManager is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div>
Added: lucy/site/trunk/content/docs/c/Lucy/Index/IndexReader.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Index/IndexReader.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Index/IndexReader.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Index/IndexReader.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,195 @@ +Title: Lucy::Index::IndexReader â C API Documentation + +<div class="c-api"> +<h2>Lucy::Index::IndexReader</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>INDEXREADER</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>IndexReader</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>IxReader</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Index/IndexReader.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Index::IndexReader â Read from an inverted index.</p> +<h3>Description</h3> +<p>IndexReader is the interface through which +<a href="../../Lucy/Search/IndexSearcher.html">IndexSearcher</a> objects access the +content of an index.</p> +<p>IndexReader objects always represent a point-in-time view of an index as it +existed at the moment the reader was created. If you want search results +to reflect modifications to an index, you must create a new IndexReader +after the update process completes.</p> +<p>IndexReaders are composites; most of the work is done by individual +<a href="../../Lucy/Index/DataReader.html">DataReader</a> sub-components, which may be +accessed via <a href="../../Lucy/Index/IndexReader.html#func_Fetch">Fetch()</a> and <a href="../../Lucy/Index/IndexReader.html#func_Obtain">Obtain()</a>. The most efficient and powerful access +to index data happens at the segment level via +<a href="../../Lucy/Index/SegReader.html">SegReader</a>âs sub-components.</p> +<h3>Functions</h3> +<dl> +<dt id="func_open">open</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>IndexReader* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>IxReader_open</strong>( + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>index</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/Snapshot.html">Snapshot</a> *<strong>snapshot</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/IndexManager.html">IndexManager</a> *<strong>manager</strong> +); +</code></pre> +<p>IndexReader is an abstract base class; open() returns the IndexReader +subclass PolyReader, which channels the output of 0 or more SegReaders.</p> +<dl> +<dt>index</dt> +<dd><p>Either a string filepath or a Folder.</p> +</dd> +<dt>snapshot</dt> +<dd><p>A Snapshot. If not supplied, the most recent snapshot +file will be used.</p> +</dd> +<dt>manager</dt> +<dd><p>An <a href="../../Lucy/Index/IndexManager.html">IndexManager</a>. +Read-locking is off by default; supplying this argument turns it on.</p> +</dd> +</dl> +</dd> +<dt id="func_do_open">do_open</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>IndexReader* +<span class="prefix">lucy_</span><strong>IxReader_do_open</strong>( + <span class="prefix">lucy_</span>IndexReader *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>index</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/Snapshot.html">Snapshot</a> *<strong>snapshot</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/IndexManager.html">IndexManager</a> *<strong>manager</strong> +); +</code></pre> +<p>Initialize and open an IndexReader.</p> +<dl> +<dt>index</dt> +<dd><p>Either a string filepath or a Folder.</p> +</dd> +<dt>snapshot</dt> +<dd><p>A Snapshot. If not supplied, the most recent snapshot +file will be used.</p> +</dd> +<dt>manager</dt> +<dd><p>An <a href="../../Lucy/Index/IndexManager.html">IndexManager</a>. +Read-locking is off by default; supplying this argument turns it on.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Doc_Max">Doc_Max <span class="comment">(abstract)</span></dt> +<dd> +<pre><code>int32_t +<span class="prefix">lucy_</span><strong>IxReader_Doc_Max</strong>( + <span class="prefix">lucy_</span>IndexReader *<strong>self</strong> +); +</code></pre> +<p>Return the maximum number of documents available to the reader, which +is also the highest possible internal document id. Documents which +have been marked as deleted but not yet purged from the index are +included in this count.</p> +</dd> +<dt id="func_Doc_Count">Doc_Count <span class="comment">(abstract)</span></dt> +<dd> +<pre><code>int32_t +<span class="prefix">lucy_</span><strong>IxReader_Doc_Count</strong>( + <span class="prefix">lucy_</span>IndexReader *<strong>self</strong> +); +</code></pre> +<p>Return the number of documents available to the reader, subtracting +any that are marked as deleted.</p> +</dd> +<dt id="func_Del_Count">Del_Count <span class="comment">(abstract)</span></dt> +<dd> +<pre><code>int32_t +<span class="prefix">lucy_</span><strong>IxReader_Del_Count</strong>( + <span class="prefix">lucy_</span>IndexReader *<strong>self</strong> +); +</code></pre> +<p>Return the number of documents which have been marked as deleted but +not yet purged from the index.</p> +</dd> +<dt id="func_Offsets">Offsets <span class="comment">(abstract)</span></dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Object/I32Array.html">I32Array</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>IxReader_Offsets</strong>( + <span class="prefix">lucy_</span>IndexReader *<strong>self</strong> +); +</code></pre> +<p>Return an array with one entry for each segment, corresponding to +segment doc_id start offset.</p> +</dd> +<dt id="func_Seg_Readers">Seg_Readers <span class="comment">(abstract)</span></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>IxReader_Seg_Readers</strong>( + <span class="prefix">lucy_</span>IndexReader *<strong>self</strong> +); +</code></pre> +<p>Return an array of all the SegReaders represented within the +IndexReader.</p> +</dd> +<dt id="func_Obtain">Obtain</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Index/DataReader.html">DataReader</a>* +<span class="prefix">lucy_</span><strong>IxReader_Obtain</strong>( + <span class="prefix">lucy_</span>IndexReader *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>api</strong> +); +</code></pre> +<p>Fetch a component, or throw an error if the component canât be found.</p> +<dl> +<dt>api</dt> +<dd><p>The name of the DataReader subclass that the desired +component must implement.</p> +</dd> +</dl> +</dd> +<dt id="func_Fetch">Fetch</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Index/DataReader.html">DataReader</a>* +<span class="prefix">lucy_</span><strong>IxReader_Fetch</strong>( + <span class="prefix">lucy_</span>IndexReader *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>api</strong> +); +</code></pre> +<p>Fetch a component, or return NULL if the component canât be +found.</p> +<dl> +<dt>api</dt> +<dd><p>The name of the DataReader subclass that the desired +component must implement.</p> +</dd> +</dl> +</dd> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>IxReader_Destroy</strong>( + <span class="prefix">lucy_</span>IndexReader *<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::Index::IndexReader is a <a href="../../Lucy/Index/DataReader.html">Lucy::Index::DataReader</a> is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Index/Indexer.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Index/Indexer.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Index/Indexer.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Index/Indexer.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,262 @@ +Title: Lucy::Index::Indexer â C API Documentation + +<div class="c-api"> +<h2>Lucy::Index::Indexer</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>INDEXER</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>Indexer</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>Indexer</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Index/Indexer.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Index::Indexer â Build inverted indexes.</p> +<h3>Description</h3> +<p>The Indexer class is Apache Lucyâs primary tool for managing the content of +inverted indexes, which may later be searched using +<a href="../../Lucy/Search/IndexSearcher.html">IndexSearcher</a>.</p> +<p>In general, only one Indexer at a time may write to an index safely. If a +write lock cannot be secured, new() will throw an exception.</p> +<p>If an index is located on a shared volume, each writer application must +identify itself by supplying an +<a href="../../Lucy/Index/IndexManager.html">IndexManager</a> with a unique +<code>host</code> id to Indexerâs constructor or index corruption will +occur. See <a href="../../Lucy/Docs/FileLocking.html">FileLocking</a> for a detailed +discussion.</p> +<p>Note: at present, <a href="../../Lucy/Index/Indexer.html#func_Delete_By_Term">Delete_By_Term()</a> and <a href="../../Lucy/Index/Indexer.html#func_Delete_By_Query">Delete_By_Query()</a> only affect +documents which had been previously committed to the index â and not any +documents added this indexing session but not yet committed. This may +change in a future update.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>Indexer* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>Indexer_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/Obj.html">Obj</a> *<strong>index</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/IndexManager.html">IndexManager</a> *<strong>manager</strong>, + int32_t <strong>flags</strong> +); +</code></pre> +<p>Open a new Indexer. If the index already exists, update it.</p> +<dl> +<dt>schema</dt> +<dd><p>A Schema.</p> +</dd> +<dt>index</dt> +<dd><p>Either a string filepath or a Folder.</p> +</dd> +<dt>manager</dt> +<dd><p>An IndexManager.</p> +</dd> +<dt>flags</dt> +<dd><p>Flags governing behavior.</p> +</dd> +</dl> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>Indexer* +<span class="prefix">lucy_</span><strong>Indexer_init</strong>( + <span class="prefix">lucy_</span>Indexer *<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/Obj.html">Obj</a> *<strong>index</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/IndexManager.html">IndexManager</a> *<strong>manager</strong>, + int32_t <strong>flags</strong> +); +</code></pre> +<p>Initialize an Indexer.</p> +<dl> +<dt>schema</dt> +<dd><p>A Schema.</p> +</dd> +<dt>index</dt> +<dd><p>Either a string filepath or a Folder.</p> +</dd> +<dt>manager</dt> +<dd><p>An IndexManager.</p> +</dd> +<dt>flags</dt> +<dd><p>Flags governing behavior.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Add_Doc">Add_Doc</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Indexer_Add_Doc</strong>( + <span class="prefix">lucy_</span>Indexer *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Document/Doc.html">Doc</a> *<strong>doc</strong>, + float <strong>boost</strong> +); +</code></pre> +<p>Add a document to the index.</p> +<dl> +<dt>doc</dt> +<dd><p>A Lucy::Document::Doc object.</p> +</dd> +<dt>boost</dt> +<dd><p>A floating point weight which affects how this document +scores.</p> +</dd> +</dl> +</dd> +<dt id="func_Add_Index">Add_Index</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Indexer_Add_Index</strong>( + <span class="prefix">lucy_</span>Indexer *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>index</strong> +); +</code></pre> +<p>Absorb an existing index into this one. The two indexes must +have matching Schemas.</p> +<dl> +<dt>index</dt> +<dd><p>Either an index path name or a Folder.</p> +</dd> +</dl> +</dd> +<dt id="func_Delete_By_Term">Delete_By_Term</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Indexer_Delete_By_Term</strong>( + <span class="prefix">lucy_</span>Indexer *<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>Mark documents which contain the supplied term as deleted, so that +they will be excluded from search results and eventually removed +altogether. The change is not apparent to search apps until after +<a href="../../Lucy/Index/Indexer.html#func_Commit">Commit()</a> succeeds.</p> +<dl> +<dt>field</dt> +<dd><p>The name of an indexed field. (If it is not specâd as +<code>indexed</code>, an error will occur.)</p> +</dd> +<dt>term</dt> +<dd><p>The term which identifies docs to be marked as deleted. If +<code>field</code> is associated with an Analyzer, <code>term</code> +will be processed automatically (so donât pre-process it yourself).</p> +</dd> +</dl> +</dd> +<dt id="func_Delete_By_Query">Delete_By_Query</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Indexer_Delete_By_Query</strong>( + <span class="prefix">lucy_</span>Indexer *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Search/Query.html">Query</a> *<strong>query</strong> +); +</code></pre> +<p>Mark documents which match the supplied Query as deleted.</p> +<dl> +<dt>query</dt> +<dd><p>A <a href="../../Lucy/Search/Query.html">Query</a>.</p> +</dd> +</dl> +</dd> +<dt id="func_Delete_By_Doc_ID">Delete_By_Doc_ID</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Indexer_Delete_By_Doc_ID</strong>( + <span class="prefix">lucy_</span>Indexer *<strong>self</strong>, + int32_t <strong>doc_id</strong> +); +</code></pre> +<p>Mark the document identified by the supplied document ID as deleted.</p> +<dl> +<dt>doc_id</dt> +<dd><p>A <a href="../../Lucy/Docs/DocIDs.html">document id</a>.</p> +</dd> +</dl> +</dd> +<dt id="func_Optimize">Optimize</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Indexer_Optimize</strong>( + <span class="prefix">lucy_</span>Indexer *<strong>self</strong> +); +</code></pre> +<p>Optimize the index for search-time performance. This may take a +while, as it can involve rewriting large amounts of data.</p> +<p>Every Indexer session which changes index content and ends in a +<a href="../../Lucy/Index/Indexer.html#func_Commit">Commit()</a> creates a new segment. Once written, segments are never +modified. However, they are periodically recycled by feeding their +content into the segment currently being written.</p> +<p>The <a href="../../Lucy/Index/Indexer.html#func_Optimize">Optimize()</a> method causes all existing index content to be fed back +into the Indexer. When <a href="../../Lucy/Index/Indexer.html#func_Commit">Commit()</a> completes after an <a href="../../Lucy/Index/Indexer.html#func_Optimize">Optimize()</a>, the +index will consist of one segment. So <a href="../../Lucy/Index/Indexer.html#func_Optimize">Optimize()</a> must be called +before <a href="../../Lucy/Index/Indexer.html#func_Commit">Commit()</a>. Also, optimizing a fresh index created from scratch +has no effect.</p> +<p>Historically, there was a significant search-time performance benefit +to collapsing down to a single segment versus even two segments. Now +the effect of collapsing is much less significant, and calling +<a href="../../Lucy/Index/Indexer.html#func_Optimize">Optimize()</a> is rarely justified.</p> +</dd> +<dt id="func_Commit">Commit</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Indexer_Commit</strong>( + <span class="prefix">lucy_</span>Indexer *<strong>self</strong> +); +</code></pre> +<p>Commit any changes made to the index. Until this is called, none of +the changes made during an indexing session are permanent.</p> +<p>Calling <a href="../../Lucy/Index/Indexer.html#func_Commit">Commit()</a> invalidates the Indexer, so if you want to make more +changes youâll need a new one.</p> +</dd> +<dt id="func_Prepare_Commit">Prepare_Commit</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Indexer_Prepare_Commit</strong>( + <span class="prefix">lucy_</span>Indexer *<strong>self</strong> +); +</code></pre> +<p>Perform the expensive setup for <a href="../../Lucy/Index/Indexer.html#func_Commit">Commit()</a> in advance, so that <a href="../../Lucy/Index/Indexer.html#func_Commit">Commit()</a> +completes quickly. (If <a href="../../Lucy/Index/Indexer.html#func_Prepare_Commit">Prepare_Commit()</a> is not called explicitly by +the user, <a href="../../Lucy/Index/Indexer.html#func_Commit">Commit()</a> will call it internally.)</p> +</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>Indexer_Get_Schema</strong>( + <span class="prefix">lucy_</span>Indexer *<strong>self</strong> +); +</code></pre> +<p>Accessor for schema.</p> +</dd> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Indexer_Destroy</strong>( + <span class="prefix">lucy_</span>Indexer *<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::Index::Indexer is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Index/Lexicon.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Index/Lexicon.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Index/Lexicon.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Index/Lexicon.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,97 @@ +Title: Lucy::Index::Lexicon â C API Documentation + +<div class="c-api"> +<h2>Lucy::Index::Lexicon</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>LEXICON</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>Lexicon</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>Lex</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Index/Lexicon.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Index::Lexicon â Iterator for a fieldâs terms.</p> +<h3>Description</h3> +<p>A Lexicon is an iterator which provides access to all the unique terms for +a given field in sorted order.</p> +<p>If an index consists of two documents with a âcontentâ field holding âthree +blind miceâ and âthree musketeersâ respectively, then iterating through the +âcontentâ fieldâs lexicon would produce this list:</p> +<pre><code>blind +mice +musketeers +three +</code></pre> +<h3>Methods</h3> +<dl> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Lex_Destroy</strong>( + <span class="prefix">lucy_</span>Lexicon *<strong>self</strong> +); +</code></pre> +<p>Generic destructor. Frees the struct itself but not any complex +member elements.</p> +</dd> +<dt id="func_Seek">Seek <span class="comment">(abstract)</span></dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Lex_Seek</strong>( + <span class="prefix">lucy_</span>Lexicon *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>target</strong> +); +</code></pre> +<p>Seek the Lexicon to the first iterator state which is greater than or +equal to <code>target</code>. If <code>target</code> is NULL, +reset the iterator.</p> +</dd> +<dt id="func_Next">Next <span class="comment">(abstract)</span></dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>Lex_Next</strong>( + <span class="prefix">lucy_</span>Lexicon *<strong>self</strong> +); +</code></pre> +<p>Proceed to the next term.</p> +<p><strong>Returns:</strong> true until the iterator is exhausted, then false.</p> +</dd> +<dt id="func_Reset">Reset <span class="comment">(abstract)</span></dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Lex_Reset</strong>( + <span class="prefix">lucy_</span>Lexicon *<strong>self</strong> +); +</code></pre> +<p>Reset the iterator. <a href="../../Lucy/Index/Lexicon.html#func_Next">Next()</a> must be called to proceed to the first +element.</p> +</dd> +<dt id="func_Get_Term">Get_Term <span class="comment">(abstract)</span></dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a>* +<span class="prefix">lucy_</span><strong>Lex_Get_Term</strong>( + <span class="prefix">lucy_</span>Lexicon *<strong>self</strong> +); +</code></pre> +<p>Return the current term, or NULL if the iterator is not in a +valid state.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Index::Lexicon is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Index/LexiconReader.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Index/LexiconReader.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Index/LexiconReader.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Index/LexiconReader.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,88 @@ +Title: Lucy::Index::LexiconReader â C API Documentation + +<div class="c-api"> +<h2>Lucy::Index::LexiconReader</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>LEXICONREADER</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>LexiconReader</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>LexReader</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Index/LexiconReader.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Index::LexiconReader â Read Lexicon data.</p> +<h3>Description</h3> +<p>LexiconReader reads term dictionary information.</p> +<h3>Methods</h3> +<dl> +<dt id="func_Lexicon">Lexicon <span class="comment">(abstract)</span></dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Index/Lexicon.html">Lexicon</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>LexReader_Lexicon</strong>( + <span class="prefix">lucy_</span>LexiconReader *<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 a new Lexicon for the given <code>field</code>. Will return +NULL if either the field is not indexed, or if no documents +contain a value for the field.</p> +<dl> +<dt>field</dt> +<dd><p>Field name.</p> +</dd> +<dt>term</dt> +<dd><p>Pre-locate the Lexicon to this term.</p> +</dd> +</dl> +</dd> +<dt id="func_Doc_Freq">Doc_Freq <span class="comment">(abstract)</span></dt> +<dd> +<pre><code>uint32_t +<span class="prefix">lucy_</span><strong>LexReader_Doc_Freq</strong>( + <span class="prefix">lucy_</span>LexiconReader *<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 where the specified term is present.</p> +</dd> +<dt id="func_Aggregator">Aggregator</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>LexiconReader* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>LexReader_Aggregator</strong>( + <span class="prefix">lucy_</span>LexiconReader *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Vector.html">Vector</a> *<strong>readers</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Object/I32Array.html">I32Array</a> *<strong>offsets</strong> +); +</code></pre> +<p>Return a LexiconReader which merges the output of other +LexiconReaders.</p> +<dl> +<dt>readers</dt> +<dd><p>An array of LexiconReaders.</p> +</dd> +<dt>offsets</dt> +<dd><p>Doc id start offsets for each reader.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Index::LexiconReader is a <a href="../../Lucy/Index/DataReader.html">Lucy::Index::DataReader</a> is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Index/PolyReader.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Index/PolyReader.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Index/PolyReader.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Index/PolyReader.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,155 @@ +Title: Lucy::Index::PolyReader â C API Documentation + +<div class="c-api"> +<h2>Lucy::Index::PolyReader</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>POLYREADER</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>PolyReader</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>PolyReader</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Index/PolyReader.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Index::PolyReader â Multi-segment implementation of IndexReader.</p> +<h3>Description</h3> +<p>PolyReader conflates index data from multiple segments. For instance, if +an index contains three segments with 10 documents each, PolyReaderâs +<a href="../../Lucy/Index/PolyReader.html#func_Doc_Max">Doc_Max()</a> method will return 30.</p> +<p>Some of PolyReaderâs <a href="../../Lucy/Index/DataReader.html">DataReader</a> components +may be less efficient or complete than the single-segment implementations +accessed via <a href="../../Lucy/Index/SegReader.html">SegReader</a>.</p> +<h3>Functions</h3> +<dl> +<dt id="func_open">open</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>PolyReader* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>PolyReader_open</strong>( + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>index</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/Snapshot.html">Snapshot</a> *<strong>snapshot</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/IndexManager.html">IndexManager</a> *<strong>manager</strong> +); +</code></pre> +<p>Create and open a PolyReader.</p> +<dl> +<dt>index</dt> +<dd><p>Either a string filepath or a <a href="../../Lucy/Store/Folder.html">Folder</a>.</p> +</dd> +<dt>snapshot</dt> +<dd><p>A Snapshot. If not supplied, the most recent snapshot +file will be used.</p> +</dd> +<dt>manager</dt> +<dd><p>An <a href="../../Lucy/Index/IndexManager.html">IndexManager</a>. +Read-locking is off by default; supplying this argument turns it on.</p> +</dd> +</dl> +</dd> +<dt id="func_do_open">do_open</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>PolyReader* +<span class="prefix">lucy_</span><strong>PolyReader_do_open</strong>( + <span class="prefix">lucy_</span>PolyReader *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>index</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/Snapshot.html">Snapshot</a> *<strong>snapshot</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/IndexManager.html">IndexManager</a> *<strong>manager</strong> +); +</code></pre> +<p>Initialize and open a PolyReader.</p> +<dl> +<dt>index</dt> +<dd><p>Either a string filepath or a <a href="../../Lucy/Store/Folder.html">Folder</a>.</p> +</dd> +<dt>snapshot</dt> +<dd><p>A Snapshot. If not supplied, the most recent snapshot +file will be used.</p> +</dd> +<dt>manager</dt> +<dd><p>An <a href="../../Lucy/Index/IndexManager.html">IndexManager</a>. +Read-locking is off by default; supplying this argument turns it on.</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>PolyReader_Doc_Max</strong>( + <span class="prefix">lucy_</span>PolyReader *<strong>self</strong> +); +</code></pre> +<p>Return the maximum number of documents available to the reader, which +is also the highest possible internal document id. Documents which +have been marked as deleted but not yet purged from the index are +included in this count.</p> +</dd> +<dt id="func_Doc_Count">Doc_Count</dt> +<dd> +<pre><code>int32_t +<span class="prefix">lucy_</span><strong>PolyReader_Doc_Count</strong>( + <span class="prefix">lucy_</span>PolyReader *<strong>self</strong> +); +</code></pre> +<p>Return the number of documents available to the reader, subtracting +any that are marked as deleted.</p> +</dd> +<dt id="func_Del_Count">Del_Count</dt> +<dd> +<pre><code>int32_t +<span class="prefix">lucy_</span><strong>PolyReader_Del_Count</strong>( + <span class="prefix">lucy_</span>PolyReader *<strong>self</strong> +); +</code></pre> +<p>Return the number of documents which have been marked as deleted but +not yet purged from the index.</p> +</dd> +<dt id="func_Offsets">Offsets</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Object/I32Array.html">I32Array</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>PolyReader_Offsets</strong>( + <span class="prefix">lucy_</span>PolyReader *<strong>self</strong> +); +</code></pre> +<p>Return an array with one entry for each segment, corresponding to +segment doc_id start offset.</p> +</dd> +<dt id="func_Seg_Readers">Seg_Readers</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>PolyReader_Seg_Readers</strong>( + <span class="prefix">lucy_</span>PolyReader *<strong>self</strong> +); +</code></pre> +<p>Return an array of all the SegReaders represented within the +IndexReader.</p> +</dd> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>PolyReader_Destroy</strong>( + <span class="prefix">lucy_</span>PolyReader *<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::Index::PolyReader is a <a href="../../Lucy/Index/IndexReader.html">Lucy::Index::IndexReader</a> is a <a href="../../Lucy/Index/DataReader.html">Lucy::Index::DataReader</a> is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Index/PostingList.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Index/PostingList.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Index/PostingList.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Index/PostingList.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,67 @@ +Title: Lucy::Index::PostingList â C API Documentation + +<div class="c-api"> +<h2>Lucy::Index::PostingList</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>POSTINGLIST</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>PostingList</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>PList</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Index/PostingList.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Index::PostingList â Term-Document pairings.</p> +<h3>Description</h3> +<p>PostingList is an iterator which supplies a list of document ids that match +a given term.</p> +<p>See <a href="../../Lucy/Docs/IRTheory.html">IRTheory</a> for definitions of âpostingâ and +âposting listâ.</p> +<h3>Methods</h3> +<dl> +<dt id="func_Get_Doc_Freq">Get_Doc_Freq <span class="comment">(abstract)</span></dt> +<dd> +<pre><code>uint32_t +<span class="prefix">lucy_</span><strong>PList_Get_Doc_Freq</strong>( + <span class="prefix">lucy_</span>PostingList *<strong>self</strong> +); +</code></pre> +<p>Return the number of documents that the PostingList contains. (This +number will include any documents which have been marked as deleted but +not yet purged.)</p> +</dd> +<dt id="func_Seek">Seek <span class="comment">(abstract)</span></dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>PList_Seek</strong>( + <span class="prefix">lucy_</span>PostingList *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>target</strong> +); +</code></pre> +<p>Prepare the PostingList object to iterate over matches for documents +that match <code>target</code>.</p> +<dl> +<dt>target</dt> +<dd><p>The term to match. If NULL, the iterator will +be empty.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Index::PostingList is a <a href="../../Lucy/Search/Matcher.html">Lucy::Search::Matcher</a> is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Index/PostingListReader.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Index/PostingListReader.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Index/PostingListReader.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Index/PostingListReader.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,70 @@ +Title: Lucy::Index::PostingListReader â C API Documentation + +<div class="c-api"> +<h2>Lucy::Index::PostingListReader</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>POSTINGLISTREADER</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>PostingListReader</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>PListReader</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Index/PostingListReader.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Index::PostingListReader â Read postings data.</p> +<h3>Description</h3> +<p>PostingListReaders produce <a href="../../Lucy/Index/PostingList.html">PostingList</a> +objects which convey document matching information.</p> +<h3>Methods</h3> +<dl> +<dt id="func_Posting_List">Posting_List <span class="comment">(abstract)</span></dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Index/PostingList.html">PostingList</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>PListReader_Posting_List</strong>( + <span class="prefix">lucy_</span>PostingListReader *<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>Returns a PostingList, or NULL if either <code>field</code> is +NULL or <code>field</code> is not present in any documents.</p> +<dl> +<dt>field</dt> +<dd><p>A field name.</p> +</dd> +<dt>term</dt> +<dd><p>If supplied, the PostingList will be pre-located to this +term using <a href="../../Lucy/Index/PostingList.html#func_Seek">Seek()</a>.</p> +</dd> +</dl> +</dd> +<dt id="func_Aggregator">Aggregator</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>PostingListReader* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>PListReader_Aggregator</strong>( + <span class="prefix">lucy_</span>PostingListReader *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Vector.html">Vector</a> *<strong>readers</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Object/I32Array.html">I32Array</a> *<strong>offsets</strong> +); +</code></pre> +<p>Returns NULL since PostingLists may only be iterated at the +segment level.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Index::PostingListReader is a <a href="../../Lucy/Index/DataReader.html">Lucy::Index::DataReader</a> is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Index/SegReader.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Index/SegReader.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Index/SegReader.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Index/SegReader.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,121 @@ +Title: Lucy::Index::SegReader â C API Documentation + +<div class="c-api"> +<h2>Lucy::Index::SegReader</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>SEGREADER</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>SegReader</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>SegReader</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Index/SegReader.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Index::SegReader â Single-segment IndexReader.</p> +<h3>Description</h3> +<p>SegReader interprets the data within a single segment of an index.</p> +<p>Generally speaking, only advanced users writing subclasses which manipulate +data at the segment level need to deal with the SegReader API directly.</p> +<p>Nearly all of SegReaderâs functionality is implemented by pluggable +components spawned by <a href="../../Lucy/Plan/Architecture.html">Architecture</a>âs +factory methods.</p> +<h3>Methods</h3> +<dl> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>SegReader_Destroy</strong>( + <span class="prefix">lucy_</span>SegReader *<strong>self</strong> +); +</code></pre> +<p>Generic destructor. Frees the struct itself but not any complex +member elements.</p> +</dd> +<dt id="func_Get_Seg_Name">Get_Seg_Name</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a>* +<span class="prefix">lucy_</span><strong>SegReader_Get_Seg_Name</strong>( + <span class="prefix">lucy_</span>SegReader *<strong>self</strong> +); +</code></pre> +<p>Return the name of the segment.</p> +</dd> +<dt id="func_Get_Seg_Num">Get_Seg_Num</dt> +<dd> +<pre><code>int64_t +<span class="prefix">lucy_</span><strong>SegReader_Get_Seg_Num</strong>( + <span class="prefix">lucy_</span>SegReader *<strong>self</strong> +); +</code></pre> +<p>Return the number of the segment.</p> +</dd> +<dt id="func_Del_Count">Del_Count</dt> +<dd> +<pre><code>int32_t +<span class="prefix">lucy_</span><strong>SegReader_Del_Count</strong>( + <span class="prefix">lucy_</span>SegReader *<strong>self</strong> +); +</code></pre> +<p>Return the number of documents which have been marked as deleted but +not yet purged from the index.</p> +</dd> +<dt id="func_Doc_Max">Doc_Max</dt> +<dd> +<pre><code>int32_t +<span class="prefix">lucy_</span><strong>SegReader_Doc_Max</strong>( + <span class="prefix">lucy_</span>SegReader *<strong>self</strong> +); +</code></pre> +<p>Return the maximum number of documents available to the reader, which +is also the highest possible internal document id. Documents which +have been marked as deleted but not yet purged from the index are +included in this count.</p> +</dd> +<dt id="func_Doc_Count">Doc_Count</dt> +<dd> +<pre><code>int32_t +<span class="prefix">lucy_</span><strong>SegReader_Doc_Count</strong>( + <span class="prefix">lucy_</span>SegReader *<strong>self</strong> +); +</code></pre> +<p>Return the number of documents available to the reader, subtracting +any that are marked as deleted.</p> +</dd> +<dt id="func_Offsets">Offsets</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Object/I32Array.html">I32Array</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>SegReader_Offsets</strong>( + <span class="prefix">lucy_</span>SegReader *<strong>self</strong> +); +</code></pre> +<p>Return an array with one entry for each segment, corresponding to +segment doc_id start offset.</p> +</dd> +<dt id="func_Seg_Readers">Seg_Readers</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>SegReader_Seg_Readers</strong>( + <span class="prefix">lucy_</span>SegReader *<strong>self</strong> +); +</code></pre> +<p>Return an array of all the SegReaders represented within the +IndexReader.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Index::SegReader is a <a href="../../Lucy/Index/IndexReader.html">Lucy::Index::IndexReader</a> is a <a href="../../Lucy/Index/DataReader.html">Lucy::Index::DataReader</a> is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Index/SegWriter.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Index/SegWriter.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Index/SegWriter.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Index/SegWriter.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,191 @@ +Title: Lucy::Index::SegWriter â C API Documentation + +<div class="c-api"> +<h2>Lucy::Index::SegWriter</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>SEGWRITER</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>SegWriter</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>SegWriter</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Index/SegWriter.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Index::SegWriter â Write one segment of an index.</p> +<h3>Description</h3> +<p>SegWriter is a conduit through which information fed to Indexer passes. It +manages <a href="../../Lucy/Index/Segment.html">Segment</a> and Inverter, invokes the +<a href="../../Lucy/Analysis/Analyzer.html">Analyzer</a> chain, and feeds low +level <a href="../../Lucy/Index/DataWriter.html">DataWriters</a> such as +PostingListWriter and DocWriter.</p> +<p>The sub-components of a SegWriter are determined by +<a href="../../Lucy/Plan/Architecture.html">Architecture</a>. DataWriter components +which are added to the stack of writers via <a href="../../Lucy/Index/SegWriter.html#func_Add_Writer">Add_Writer()</a> have +Add_Inverted_Doc() invoked for each document supplied to SegWriterâs +<a href="../../Lucy/Index/SegWriter.html#func_Add_Doc">Add_Doc()</a>.</p> +<h3>Methods</h3> +<dl> +<dt id="func_Register">Register</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>SegWriter_Register</strong>( + <span class="prefix">lucy_</span>SegWriter *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>api</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/DataWriter.html">DataWriter</a> *<strong>component</strong> <span class="comment">// decremented</span> +); +</code></pre> +<p>Register a DataWriter component with the SegWriter. (Note that +registration simply makes the writer available via <a href="../../Lucy/Index/SegWriter.html#func_Fetch">Fetch()</a>, so you may +also want to call <a href="../../Lucy/Index/SegWriter.html#func_Add_Writer">Add_Writer()</a>).</p> +<dl> +<dt>api</dt> +<dd><p>The name of the DataWriter api which <code>writer</code> +implements.</p> +</dd> +<dt>component</dt> +<dd><p>A DataWriter.</p> +</dd> +</dl> +</dd> +<dt id="func_Fetch">Fetch</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a>* +<span class="prefix">lucy_</span><strong>SegWriter_Fetch</strong>( + <span class="prefix">lucy_</span>SegWriter *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>api</strong> +); +</code></pre> +<p>Retrieve a registered component.</p> +<dl> +<dt>api</dt> +<dd><p>The name of the DataWriter api which the component +implements.</p> +</dd> +</dl> +</dd> +<dt id="func_Add_Writer">Add_Writer</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>SegWriter_Add_Writer</strong>( + <span class="prefix">lucy_</span>SegWriter *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/DataWriter.html">DataWriter</a> *<strong>writer</strong> <span class="comment">// decremented</span> +); +</code></pre> +<p>Add a DataWriter to the SegWriterâs stack of writers.</p> +</dd> +<dt id="func_Add_Doc">Add_Doc</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>SegWriter_Add_Doc</strong>( + <span class="prefix">lucy_</span>SegWriter *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Document/Doc.html">Doc</a> *<strong>doc</strong>, + float <strong>boost</strong> +); +</code></pre> +<p>Add a document to the segment. Inverts <code>doc</code>, increments +the Segmentâs internal document id, then calls Add_Inverted_Doc(), +feeding all sub-writers.</p> +</dd> +<dt id="func_Add_Segment">Add_Segment</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>SegWriter_Add_Segment</strong>( + <span class="prefix">lucy_</span>SegWriter *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/SegReader.html">SegReader</a> *<strong>reader</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Object/I32Array.html">I32Array</a> *<strong>doc_map</strong> +); +</code></pre> +<p>Add content from an existing segment into the one currently being +written.</p> +<dl> +<dt>reader</dt> +<dd><p>The SegReader containing content to add.</p> +</dd> +<dt>doc_map</dt> +<dd><p>An array of integers mapping old document ids to +new. Deleted documents are mapped to 0, indicating that they should be +skipped.</p> +</dd> +</dl> +</dd> +<dt id="func_Merge_Segment">Merge_Segment</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>SegWriter_Merge_Segment</strong>( + <span class="prefix">lucy_</span>SegWriter *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/SegReader.html">SegReader</a> *<strong>reader</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Object/I32Array.html">I32Array</a> *<strong>doc_map</strong> +); +</code></pre> +<p>Move content from an existing segment into the one currently being +written.</p> +<p>The default implementation calls <a href="../../Lucy/Index/SegWriter.html#func_Add_Segment">Add_Segment()</a> then <a href="../../Lucy/Index/SegWriter.html#func_Delete_Segment">Delete_Segment()</a>.</p> +<dl> +<dt>reader</dt> +<dd><p>The SegReader containing content to merge, which must +represent a segment which is part of the the current snapshot.</p> +</dd> +<dt>doc_map</dt> +<dd><p>An array of integers mapping old document ids to +new. Deleted documents are mapped to 0, indicating that they should be +skipped.</p> +</dd> +</dl> +</dd> +<dt id="func_Delete_Segment">Delete_Segment</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>SegWriter_Delete_Segment</strong>( + <span class="prefix">lucy_</span>SegWriter *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Index/SegReader.html">SegReader</a> *<strong>reader</strong> +); +</code></pre> +<p>Remove a segmentâs data. The default implementation is a no-op, as +all files within the segment directory will be automatically deleted. +Subclasses which manage their own files outside of the segment system +should override this method and use it as a trigger for cleaning up +obsolete data.</p> +<dl> +<dt>reader</dt> +<dd><p>The SegReader containing content to merge, which must +represent a segment which is part of the the current snapshot.</p> +</dd> +</dl> +</dd> +<dt id="func_Finish">Finish</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>SegWriter_Finish</strong>( + <span class="prefix">lucy_</span>SegWriter *<strong>self</strong> +); +</code></pre> +<p>Complete the segment: close all streams, store metadata, etc.</p> +</dd> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>SegWriter_Destroy</strong>( + <span class="prefix">lucy_</span>SegWriter *<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::Index::SegWriter is a <a href="../../Lucy/Index/DataWriter.html">Lucy::Index::DataWriter</a> is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Index/Segment.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Index/Segment.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Index/Segment.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Index/Segment.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,177 @@ +Title: Lucy::Index::Segment â C API Documentation + +<div class="c-api"> +<h2>Lucy::Index::Segment</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>SEGMENT</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>Segment</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>Seg</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Index/Segment.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Index::Segment â Warehouse for information about one segment of an inverted index.</p> +<h3>Description</h3> +<p>Apache Lucyâs indexes are made up of individual âsegmentsâ, each of which is +is an independent inverted index. On the file system, each segment is a +directory within the main index directory whose name starts with âseg_â: +âseg_2â, âseg_5aâ, etc.</p> +<p>Each Segment object keeps track of information about an index segment: its +fields, document count, and so on. The Segment object itself writes one +file, <code>segmeta.json</code>; besides storing info needed by Segment +itself, the âsegmetaâ file serves as a central repository for metadata +generated by other index components â relieving them of the burden of +storing metadata themselves.</p> +<h3>Methods</h3> +<dl> +<dt id="func_Add_Field">Add_Field</dt> +<dd> +<pre><code>int32_t +<span class="prefix">lucy_</span><strong>Seg_Add_Field</strong>( + <span class="prefix">lucy_</span>Segment *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>field</strong> +); +</code></pre> +<p>Register a new field and assign it a field number. If the field was +already known, nothing happens.</p> +<dl> +<dt>field</dt> +<dd><p>Field name.</p> +</dd> +</dl> +<p><strong>Returns:</strong> the fieldâs field number, which is a positive integer.</p> +</dd> +<dt id="func_Store_Metadata">Store_Metadata</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Seg_Store_Metadata</strong>( + <span class="prefix">lucy_</span>Segment *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>key</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>metadata</strong> <span class="comment">// decremented</span> +); +</code></pre> +<p>Store arbitrary information in the segmentâs metadata hash, to be +serialized later. Throws an error if <code>key</code> is used twice.</p> +<dl> +<dt>key</dt> +<dd><p>String identifying an index component.</p> +</dd> +<dt>metadata</dt> +<dd><p>JSON-izable data structure.</p> +</dd> +</dl> +</dd> +<dt id="func_Fetch_Metadata">Fetch_Metadata</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a>* +<span class="prefix">lucy_</span><strong>Seg_Fetch_Metadata</strong>( + <span class="prefix">lucy_</span>Segment *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>key</strong> +); +</code></pre> +<p>Fetch a value from the Segmentâs metadata hash.</p> +</dd> +<dt id="func_Field_Num">Field_Num</dt> +<dd> +<pre><code>int32_t +<span class="prefix">lucy_</span><strong>Seg_Field_Num</strong>( + <span class="prefix">lucy_</span>Segment *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>field</strong> +); +</code></pre> +<p>Given a field name, return its field number for this segment (which +may differ from its number in other segments). Return 0 (an invalid +field number) if the field name canât be found.</p> +<dl> +<dt>field</dt> +<dd><p>Field name.</p> +</dd> +</dl> +</dd> +<dt id="func_Field_Name">Field_Name</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a>* +<span class="prefix">lucy_</span><strong>Seg_Field_Name</strong>( + <span class="prefix">lucy_</span>Segment *<strong>self</strong>, + int32_t <strong>field_num</strong> +); +</code></pre> +<p>Given a field number, return the name of its field, or NULL +if the field name canât be found.</p> +</dd> +<dt id="func_Get_Name">Get_Name</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a>* +<span class="prefix">lucy_</span><strong>Seg_Get_Name</strong>( + <span class="prefix">lucy_</span>Segment *<strong>self</strong> +); +</code></pre> +<p>Getter for the objectâs seg name.</p> +</dd> +<dt id="func_Get_Number">Get_Number</dt> +<dd> +<pre><code>int64_t +<span class="prefix">lucy_</span><strong>Seg_Get_Number</strong>( + <span class="prefix">lucy_</span>Segment *<strong>self</strong> +); +</code></pre> +<p>Getter for the segment number.</p> +</dd> +<dt id="func_Set_Count">Set_Count</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Seg_Set_Count</strong>( + <span class="prefix">lucy_</span>Segment *<strong>self</strong>, + int64_t <strong>count</strong> +); +</code></pre> +<p>Setter for the objectâs document count.</p> +</dd> +<dt id="func_Get_Count">Get_Count</dt> +<dd> +<pre><code>int64_t +<span class="prefix">lucy_</span><strong>Seg_Get_Count</strong>( + <span class="prefix">lucy_</span>Segment *<strong>self</strong> +); +</code></pre> +<p>Getter for the objectâs document count.</p> +</dd> +<dt id="func_Compare_To">Compare_To</dt> +<dd> +<pre><code>int32_t +<span class="prefix">lucy_</span><strong>Seg_Compare_To</strong>( + <span class="prefix">lucy_</span>Segment *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/Obj.html">Obj</a> *<strong>other</strong> +); +</code></pre> +<p>Compare by segment number.</p> +</dd> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Seg_Destroy</strong>( + <span class="prefix">lucy_</span>Segment *<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::Index::Segment is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Index/Similarity.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Index/Similarity.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Index/Similarity.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Index/Similarity.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,112 @@ +Title: Lucy::Index::Similarity â C API Documentation + +<div class="c-api"> +<h2>Lucy::Index::Similarity</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>SIMILARITY</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>Similarity</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>Sim</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Index/Similarity.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Index::Similarity â Judge how well a document matches a query.</p> +<h3>Description</h3> +<p>After determining whether a document matches a given query, a score must be +calculated which indicates how <em>well</em> the document matches the query. The +Similarity class is used to judge how âsimilarâ the query and the document +are to each other; the closer the resemblance, they higher the document +scores.</p> +<p>The default implementation uses Luceneâs modified cosine similarity +measure. Subclasses might tweak the existing algorithms, or might be used +in conjunction with custom Query subclasses to implement arbitrary scoring +schemes.</p> +<p>Most of the methods operate on single fields, but some are used to combine +scores from multiple fields.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>Similarity* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>Sim_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>Similarity* +<span class="prefix">lucy_</span><strong>Sim_init</strong>( + <span class="prefix">lucy_</span>Similarity *<strong>self</strong> +); +</code></pre> +<p>Initialize a Similarity.</p> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Length_Norm">Length_Norm</dt> +<dd> +<pre><code>float +<span class="prefix">lucy_</span><strong>Sim_Length_Norm</strong>( + <span class="prefix">lucy_</span>Similarity *<strong>self</strong>, + uint32_t <strong>num_tokens</strong> +); +</code></pre> +<p>Dampen the scores of long documents.</p> +<p>After a field is broken up into terms at index-time, each term must be +assigned a weight. One of the factors in calculating this weight is +the number of tokens that the original field was broken into.</p> +<p>Typically, we assume that the more tokens in a field, the less +important any one of them is â so that, e.g. 5 mentions of âKafkaâ in +a short article are given more heft than 5 mentions of âKafkaâ in an +entire book. The default implementation of length_norm expresses this +using an inverted square root.</p> +<p>However, the inverted square root has a tendency to reward very short +fields highly, which isnât always appropriate for fields you expect to +have a lot of tokens on average.</p> +</dd> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Sim_Destroy</strong>( + <span class="prefix">lucy_</span>Similarity *<strong>self</strong> +); +</code></pre> +<p>Generic destructor. Frees the struct itself but not any complex +member elements.</p> +</dd> +<dt id="func_Equals">Equals</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>Sim_Equals</strong>( + <span class="prefix">lucy_</span>Similarity *<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::Index::Similarity is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Index/Snapshot.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Index/Snapshot.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Index/Snapshot.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Index/Snapshot.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,175 @@ +Title: Lucy::Index::Snapshot â C API Documentation + +<div class="c-api"> +<h2>Lucy::Index::Snapshot</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>SNAPSHOT</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>Snapshot</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>Snapshot</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Index/Snapshot.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Index::Snapshot â Point-in-time index file list.</p> +<h3>Description</h3> +<p>A Snapshot is list of index files and folders. Because index files, once +written, are never modified, a Snapshot defines a point-in-time view of the +data in an index.</p> +<p><a href="../../Lucy/Index/IndexReader.html">IndexReader</a> objects interpret the data +associated with a single Snapshot.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>Snapshot* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>Snapshot_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>Snapshot* +<span class="prefix">lucy_</span><strong>Snapshot_init</strong>( + <span class="prefix">lucy_</span>Snapshot *<strong>self</strong> +); +</code></pre> +<p>Initialize a Snapshot.</p> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_List">List</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>Snapshot_List</strong>( + <span class="prefix">lucy_</span>Snapshot *<strong>self</strong> +); +</code></pre> +<p>Return an array of all entries.</p> +</dd> +<dt id="func_Num_Entries">Num_Entries</dt> +<dd> +<pre><code>uint32_t +<span class="prefix">lucy_</span><strong>Snapshot_Num_Entries</strong>( + <span class="prefix">lucy_</span>Snapshot *<strong>self</strong> +); +</code></pre> +<p>Return the number of entries (including directories).</p> +</dd> +<dt id="func_Add_Entry">Add_Entry</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Snapshot_Add_Entry</strong>( + <span class="prefix">lucy_</span>Snapshot *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>entry</strong> +); +</code></pre> +<p>Add a filepath to the snapshot.</p> +</dd> +<dt id="func_Delete_Entry">Delete_Entry</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>Snapshot_Delete_Entry</strong>( + <span class="prefix">lucy_</span>Snapshot *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>entry</strong> +); +</code></pre> +<p>Delete a filepath from the snapshot.</p> +<p><strong>Returns:</strong> true if the entry existed and was successfully deleted, false +otherwise.</p> +</dd> +<dt id="func_Read_File">Read_File</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>Snapshot* +<span class="prefix">lucy_</span><strong>Snapshot_Read_File</strong>( + <span class="prefix">lucy_</span>Snapshot *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Store/Folder.html">Folder</a> *<strong>folder</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>path</strong> +); +</code></pre> +<p>Decode a snapshot file and initialize the object to reflect its +contents.</p> +<dl> +<dt>folder</dt> +<dd><p>A Folder.</p> +</dd> +<dt>path</dt> +<dd><p>The location of the snapshot file. If not supplied, the +most recent snapshot file in the base directory will be chosen.</p> +</dd> +</dl> +<p><strong>Returns:</strong> the Snapshot object itself</p> +</dd> +<dt id="func_Write_File">Write_File</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Snapshot_Write_File</strong>( + <span class="prefix">lucy_</span>Snapshot *<strong>self</strong>, + <span class="prefix">lucy_</span><a href="../../Lucy/Store/Folder.html">Folder</a> *<strong>folder</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>path</strong> +); +</code></pre> +<p>Write a snapshot file. The caller must lock the index while this +operation takes place, and the operation will fail if the snapshot file +already exists.</p> +<dl> +<dt>folder</dt> +<dd><p>A Folder.</p> +</dd> +<dt>path</dt> +<dd><p>The path of the file to write. If NULL, a file +name will be chosen which supersedes the latest snapshot file in the +index folder.</p> +</dd> +</dl> +</dd> +<dt id="func_Set_Path">Set_Path</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Snapshot_Set_Path</strong>( + <span class="prefix">lucy_</span>Snapshot *<strong>self</strong>, + <span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a> *<strong>path</strong> +); +</code></pre> +<p>Set the path to the file that the Snapshot object serves as a proxy +for.</p> +</dd> +<dt id="func_Get_Path">Get_Path</dt> +<dd> +<pre><code><span class="prefix">cfish_</span><a href="../../Clownfish/String.html">String</a>* +<span class="prefix">lucy_</span><strong>Snapshot_Get_Path</strong>( + <span class="prefix">lucy_</span>Snapshot *<strong>self</strong> +); +</code></pre> +<p>Get the path to the snapshot file. Initially NULL; updated +by <a href="../../Lucy/Index/Snapshot.html#func_Read_File">Read_File()</a>, <a href="../../Lucy/Index/Snapshot.html#func_Write_File">Write_File()</a>, and <a href="../../Lucy/Index/Snapshot.html#func_Set_Path">Set_Path()</a>.</p> +</dd> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>Snapshot_Destroy</strong>( + <span class="prefix">lucy_</span>Snapshot *<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::Index::Snapshot is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div> Added: lucy/site/trunk/content/docs/c/Lucy/Object/BitVector.mdtext URL: http://svn.apache.org/viewvc/lucy/site/trunk/content/docs/c/Lucy/Object/BitVector.mdtext?rev=1737682&view=auto ============================================================================== --- lucy/site/trunk/content/docs/c/Lucy/Object/BitVector.mdtext (added) +++ lucy/site/trunk/content/docs/c/Lucy/Object/BitVector.mdtext Mon Apr 4 12:55:10 2016 @@ -0,0 +1,287 @@ +Title: Lucy::Object::BitVector â C API Documentation + +<div class="c-api"> +<h2>Lucy::Object::BitVector</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>BITVECTOR</code></td> +</tr> +<tr> +<td class="label">struct symbol</td> +<td><code><span class="prefix">lucy_</span>BitVector</code></td> +</tr> +<tr> +<td class="label">class nickname</td> +<td><code><span class="prefix">lucy_</span>BitVec</code></td> +</tr> +<tr> +<td class="label">header file</td> +<td><code>Lucy/Object/BitVector.h</code></td> +</tr> +</table> +<h3>Name</h3> +<p>Lucy::Object::BitVector â An array of bits.</p> +<h3>Description</h3> +<p>BitVector is a growable array of bits. All bits are initially zero.</p> +<h3>Functions</h3> +<dl> +<dt id="func_new">new</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>BitVector* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>BitVec_new</strong>( + uint32_t <strong>capacity</strong> +); +</code></pre> +<p>Create a new BitVector.</p> +<dl> +<dt>capacity</dt> +<dd><p>The number of bits that the initial array should be +able to hold.</p> +</dd> +</dl> +</dd> +<dt id="func_init">init</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>BitVector* +<span class="prefix">lucy_</span><strong>BitVec_init</strong>( + <span class="prefix">lucy_</span>BitVector *<strong>self</strong>, + uint32_t <strong>capacity</strong> +); +</code></pre> +<p>Initialize a BitVector.</p> +<dl> +<dt>capacity</dt> +<dd><p>The number of bits that the initial array should be +able to hold.</p> +</dd> +</dl> +</dd> +</dl> +<h3>Methods</h3> +<dl> +<dt id="func_Get">Get</dt> +<dd> +<pre><code>bool +<span class="prefix">lucy_</span><strong>BitVec_Get</strong>( + <span class="prefix">lucy_</span>BitVector *<strong>self</strong>, + uint32_t <strong>tick</strong> +); +</code></pre> +<p>Return true if the bit at <code>tick</code> has been set, false if it +hasnât (regardless of whether it lies within the bounds of the +objectâs capacity).</p> +<dl> +<dt>tick</dt> +<dd><p>The requested bit.</p> +</dd> +</dl> +</dd> +<dt id="func_Set">Set</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>BitVec_Set</strong>( + <span class="prefix">lucy_</span>BitVector *<strong>self</strong>, + uint32_t <strong>tick</strong> +); +</code></pre> +<p>Set the bit at <code>tick</code> to 1.</p> +<dl> +<dt>tick</dt> +<dd><p>The bit to be set.</p> +</dd> +</dl> +</dd> +<dt id="func_Next_Hit">Next_Hit</dt> +<dd> +<pre><code>int32_t +<span class="prefix">lucy_</span><strong>BitVec_Next_Hit</strong>( + <span class="prefix">lucy_</span>BitVector *<strong>self</strong>, + uint32_t <strong>tick</strong> +); +</code></pre> +<p>Returns the next set bit equal to or greater than <code>tick</code>, +or -1 if no such bit exists.</p> +</dd> +<dt id="func_Clear">Clear</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>BitVec_Clear</strong>( + <span class="prefix">lucy_</span>BitVector *<strong>self</strong>, + uint32_t <strong>tick</strong> +); +</code></pre> +<p>Clear the indicated bit. (i.e. set it to 0).</p> +<dl> +<dt>tick</dt> +<dd><p>The bit to be cleared.</p> +</dd> +</dl> +</dd> +<dt id="func_Clear_All">Clear_All</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>BitVec_Clear_All</strong>( + <span class="prefix">lucy_</span>BitVector *<strong>self</strong> +); +</code></pre> +<p>Clear all bits.</p> +</dd> +<dt id="func_Grow">Grow</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>BitVec_Grow</strong>( + <span class="prefix">lucy_</span>BitVector *<strong>self</strong>, + uint32_t <strong>capacity</strong> +); +</code></pre> +<p>If the BitVector does not already have enough room to hold the +indicated number of bits, allocate more memory so that it can.</p> +<dl> +<dt>capacity</dt> +<dd><p>Least number of bits the BitVector should accomodate.</p> +</dd> +</dl> +</dd> +<dt id="func_And">And</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>BitVec_And</strong>( + <span class="prefix">lucy_</span>BitVector *<strong>self</strong>, + const <span class="prefix">lucy_</span>BitVector *<strong>other</strong> +); +</code></pre> +<p>Modify the BitVector so that only bits which remain set are those +which 1) were already set in this BitVector, and 2) were also set in +the other BitVector.</p> +<dl> +<dt>other</dt> +<dd><p>Another BitVector.</p> +</dd> +</dl> +</dd> +<dt id="func_Or">Or</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>BitVec_Or</strong>( + <span class="prefix">lucy_</span>BitVector *<strong>self</strong>, + const <span class="prefix">lucy_</span>BitVector *<strong>other</strong> +); +</code></pre> +<p>Modify the BitVector, setting all bits which are set in the other +BitVector if they were not already set.</p> +<dl> +<dt>other</dt> +<dd><p>Another BitVector.</p> +</dd> +</dl> +</dd> +<dt id="func_Xor">Xor</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>BitVec_Xor</strong>( + <span class="prefix">lucy_</span>BitVector *<strong>self</strong>, + const <span class="prefix">lucy_</span>BitVector *<strong>other</strong> +); +</code></pre> +<p>Modify the BitVector, performing an XOR operation against the other.</p> +<dl> +<dt>other</dt> +<dd><p>Another BitVector.</p> +</dd> +</dl> +</dd> +<dt id="func_And_Not">And_Not</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>BitVec_And_Not</strong>( + <span class="prefix">lucy_</span>BitVector *<strong>self</strong>, + const <span class="prefix">lucy_</span>BitVector *<strong>other</strong> +); +</code></pre> +<p>Modify the BitVector, clearing all bits which are set in the other.</p> +<dl> +<dt>other</dt> +<dd><p>Another BitVector.</p> +</dd> +</dl> +</dd> +<dt id="func_Flip">Flip</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>BitVec_Flip</strong>( + <span class="prefix">lucy_</span>BitVector *<strong>self</strong>, + uint32_t <strong>tick</strong> +); +</code></pre> +<p>Invert the value of a bit.</p> +<dl> +<dt>tick</dt> +<dd><p>The bit to invert.</p> +</dd> +</dl> +</dd> +<dt id="func_Flip_Block">Flip_Block</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>BitVec_Flip_Block</strong>( + <span class="prefix">lucy_</span>BitVector *<strong>self</strong>, + uint32_t <strong>offset</strong>, + uint32_t <strong>length</strong> +); +</code></pre> +<p>Invert each bit within a contiguous block.</p> +<dl> +<dt>offset</dt> +<dd><p>Lower bound.</p> +</dd> +<dt>length</dt> +<dd><p>The number of bits to flip.</p> +</dd> +</dl> +</dd> +<dt id="func_Count">Count</dt> +<dd> +<pre><code>uint32_t +<span class="prefix">lucy_</span><strong>BitVec_Count</strong>( + <span class="prefix">lucy_</span>BitVector *<strong>self</strong> +); +</code></pre> +<p>Return a count of the number of set bits.</p> +</dd> +<dt id="func_To_Array">To_Array</dt> +<dd> +<pre><code><span class="prefix">lucy_</span><a href="../../Lucy/Object/I32Array.html">I32Array</a>* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>BitVec_To_Array</strong>( + <span class="prefix">lucy_</span>BitVector *<strong>self</strong> +); +</code></pre> +<p>Return an array where each element represents a set bit.</p> +</dd> +<dt id="func_Destroy">Destroy</dt> +<dd> +<pre><code>void +<span class="prefix">lucy_</span><strong>BitVec_Destroy</strong>( + <span class="prefix">lucy_</span>BitVector *<strong>self</strong> +); +</code></pre> +<p>Generic destructor. Frees the struct itself but not any complex +member elements.</p> +</dd> +<dt id="func_Clone">Clone</dt> +<dd> +<pre><code><span class="prefix">lucy_</span>BitVector* <span class="comment">// incremented</span> +<span class="prefix">lucy_</span><strong>BitVec_Clone</strong>( + <span class="prefix">lucy_</span>BitVector *<strong>self</strong> +); +</code></pre> +<p>Return a clone of the object.</p> +</dd> +</dl> +<h3>Inheritance</h3> +<p>Lucy::Object::BitVector is a <a href="../../Clownfish/Obj.html">Clownfish::Obj</a>.</p> +</div>
