Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/Indexer.html
==============================================================================
--- websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/Indexer.html
(added)
+++ websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/Indexer.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,170 @@
+
+<html>
+<head>
+<title>Lucy::Index::Indexer - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Index::Indexer - Build inverted indexes.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $indexer = Lucy::Index::Indexer->new(
+ schema => $schema,
+ index => '/path/to/index',
+ create => 1,
+ );
+ while ( my ( $title, $content ) = each %source_docs ) {
+ $indexer->add_doc({
+ title => $title,
+ content => $content,
+ });
+ }
+ $indexer->commit;</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<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">Lucy::Docs::FileLocking</a> for a
detailed discussion.</p>
+
+<p>Note: at present, delete_by_term() and delete_by_query() 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>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new-labeled-params">new( <i>[labeled params]</i> )</h2>
+
+<pre><code> my $indexer = Lucy::Index::Indexer->new(
+ schema => $schema, # required at index creation
+ index => '/path/to/index', # required
+ create => 1, # default: 0
+ truncate => 1, # default: 0
+ manager => $manager # default: created internally
+ );</code></pre>
+
+<ul>
+
+<li><p><b>schema</b> - A Schema. Required when index is being created; if not
supplied, will be extracted from the index folder.</p>
+
+</li>
+<li><p><b>index</b> - Either a filepath to an index or a Folder.</p>
+
+</li>
+<li><p><b>create</b> - If true and the index directory does not exist, attempt
to create it.</p>
+
+</li>
+<li><p><b>truncate</b> - If true, proceed with the intention of discarding all
previous indexing data. The old data will remain intact and visible until
commit() succeeds.</p>
+
+</li>
+<li><p><b>manager</b> - An IndexManager.</p>
+
+</li>
+</ul>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="add_doc">add_doc(...)</h2>
+
+<pre><code> $indexer->add_doc($doc);
+ $indexer->add_doc( { field_name => $field_value } );
+ $indexer->add_doc(
+ doc => { field_name => $field_value },
+ boost => 2.5, # default: 1.0
+ );</code></pre>
+
+<p>Add a document to the index. Accepts either a single argument or labeled
params.</p>
+
+<ul>
+
+<li><p><b>doc</b> - Either a Lucy::Document::Doc object, or a hashref (which
will be attached to a Lucy::Document::Doc object internally).</p>
+
+</li>
+<li><p><b>boost</b> - A floating point weight which affects how this document
scores.</p>
+
+</li>
+</ul>
+
+<h2 id="add_index-index">add_index(index)</h2>
+
+<p>Absorb an existing index into this one. The two indexes must have matching
Schemas.</p>
+
+<ul>
+
+<li><p><b>index</b> - Either an index path name or a Folder.</p>
+
+</li>
+</ul>
+
+<h2 id="optimize">optimize()</h2>
+
+<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 commit()
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 optimize() method causes all existing index content to be fed back into
the Indexer. When commit() completes after an optimize(), the index will
consist of one segment. So optimize() must be called before commit(). 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 optimize() is rarely
justified.</p>
+
+<h2 id="commit">commit()</h2>
+
+<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 commit() invalidates the Indexer, so if you want to make more
changes you'll need a new one.</p>
+
+<h2 id="prepare_commit">prepare_commit()</h2>
+
+<p>Perform the expensive setup for commit() in advance, so that commit()
completes quickly. (If prepare_commit() is not called explicitly by the user,
commit() will call it internally.)</p>
+
+<h2 id="delete_by_term-labeled-params">delete_by_term( <i>[labeled params]</i>
)</h2>
+
+<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 commit() succeeds.</p>
+
+<ul>
+
+<li><p><b>field</b> - The name of an indexed field. (If it is not spec'd
as <code>indexed</code>, an error will occur.)</p>
+
+</li>
+<li><p><b>term</b> - 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>
+
+</li>
+</ul>
+
+<h2 id="delete_by_query-query">delete_by_query(query)</h2>
+
+<p>Mark documents which match the supplied Query as deleted.</p>
+
+<ul>
+
+<li><p><b>query</b> - A <a href="../../Lucy/Search/Query.html">Query</a>.</p>
+
+</li>
+</ul>
+
+<h2 id="delete_by_doc_id-doc_id">delete_by_doc_id(doc_id)</h2>
+
+<p>Mark the document identified by the supplied document ID as deleted.</p>
+
+<ul>
+
+<li><p><b>doc_id</b> - A <a href="../../Lucy/Docs/DocIDs.html">document
id</a>.</p>
+
+</li>
+</ul>
+
+<h2 id="get_schema">get_schema()</h2>
+
+<p>Accessor for schema.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Index::Indexer isa Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/Lexicon.html
==============================================================================
--- websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/Lexicon.html
(added)
+++ websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/Lexicon.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,59 @@
+
+<html>
+<head>
+<title>Lucy::Index::Lexicon - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Index::Lexicon - Iterator for a field's terms.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $lex_reader =
$seg_reader->obtain('Lucy::Index::LexiconReader');
+ my $lexicon = $lex_reader->lexicon( field => 'content' );
+ while ( $lexicon->next ) {
+ print $lexicon->get_term . "\n";
+ }</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<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>
+
+<h1 id="ABSTRACT-METHODS">ABSTRACT METHODS</h1>
+
+<h2 id="seek-target">seek(target)</h2>
+
+<p>Seek the Lexicon to the first iterator state which is greater than or equal
to <code>target</code>. If <code>target</code> is undef, reset the iterator.</p>
+
+<h2 id="next">next()</h2>
+
+<p>Proceed to the next term.</p>
+
+<p>Returns: true until the iterator is exhausted, then false.</p>
+
+<h2 id="get_term">get_term()</h2>
+
+<p>Return the current term, or undef if the iterator is not in a valid
state.</p>
+
+<h2 id="reset">reset()</h2>
+
+<p>Reset the iterator. next() must be called to proceed to the first
element.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Index::Lexicon isa Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/LexiconReader.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/LexiconReader.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/LexiconReader.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,49 @@
+
+<html>
+<head>
+<title>Lucy::Index::LexiconReader - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Index::LexiconReader - Read Lexicon data.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $lex_reader =
$seg_reader->obtain("Lucy::Index::LexiconReader");
+ my $lexicon = $lex_reader->lexicon( field => 'title'
);</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>LexiconReader reads term dictionary information.</p>
+
+<h1 id="ABSTRACT-METHODS">ABSTRACT METHODS</h1>
+
+<h2 id="lexicon-labeled-params">lexicon( <i>[labeled params]</i> )</h2>
+
+<p>Return a new Lexicon for the given <code>field</code>. Will return undef if
either the field is not indexed, or if no documents contain a value for the
field.</p>
+
+<ul>
+
+<li><p><b>field</b> - Field name.</p>
+
+</li>
+<li><p><b>term</b> - Pre-locate the Lexicon to this term.</p>
+
+</li>
+</ul>
+
+<h2 id="doc_freq-labeled-params">doc_freq( <i>[labeled params]</i> )</h2>
+
+<p>Return the number of documents where the specified term is present.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Index::LexiconReader isa <a
href="../../Lucy/Index/DataReader.html">Lucy::Index::DataReader</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/PolyReader.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/PolyReader.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/PolyReader.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,37 @@
+
+<html>
+<head>
+<title>Lucy::Index::PolyReader - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Index::PolyReader - Multi-segment implementation of IndexReader.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $polyreader = Lucy::Index::IndexReader->open(
+ index => '/path/to/index',
+ );
+ my $doc_reader =
$polyreader->obtain("Lucy::Index::DocReader");
+ for my $doc_id ( 1 .. $polyreader->doc_max ) {
+ my $doc = $doc_reader->fetch_doc($doc_id);
+ print " $doc_id: $doc->{title}\n";
+ }</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>PolyReader conflates index data from multiple segments. For instance, if an
index contains three segments with 10 documents each, PolyReader's
doc_max() method will return 30.</p>
+
+<p>Some of PolyReader's <a
href="../../Lucy/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>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Index::PolyReader isa <a
href="../../Lucy/Index/IndexReader.html">Lucy::Index::IndexReader</a> isa <a
href="../../Lucy/Index/DataReader.html">Lucy::Index::DataReader</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/PostingList.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/PostingList.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/PostingList.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,80 @@
+
+<html>
+<head>
+<title>Lucy::Index::PostingList - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Index::PostingList - Term-Document pairings.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $posting_list_reader
+ = $seg_reader->obtain("Lucy::Index::PostingListReader");
+ my $posting_list = $posting_list_reader->posting_list(
+ field => 'content',
+ term => 'foo',
+ );
+ while ( my $doc_id = $posting_list->next ) {
+ say "Matching doc id: $doc_id";
+ }</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<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">Lucy::Docs::IRTheory</a> for
definitions of "posting" and "posting list".</p>
+
+<h1 id="ABSTRACT-METHODS">ABSTRACT METHODS</h1>
+
+<h2 id="next">next()</h2>
+
+<p>Proceed to the next doc id.</p>
+
+<p>Returns: A positive doc id, or 0 once the iterator is exhausted.</p>
+
+<h2 id="get_doc_id">get_doc_id()</h2>
+
+<p>Return the current doc id. Valid only after a successful call to next() or
advance() and must not be called otherwise.</p>
+
+<h2 id="get_doc_freq">get_doc_freq()</h2>
+
+<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>
+
+<h2 id="seek-target">seek(target)</h2>
+
+<p>Prepare the PostingList object to iterate over matches for documents that
match <code>target</code>.</p>
+
+<ul>
+
+<li><p><b>target</b> - The term to match. If undef, the iterator will be
empty.</p>
+
+</li>
+</ul>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="advance-target">advance(target)</h2>
+
+<p>Advance the iterator to the first doc id greater than or equal to
<code>target</code>. The default implementation simply calls next() over and
over, but subclasses have the option of doing something more efficient.</p>
+
+<ul>
+
+<li><p><b>target</b> - A positive doc id, which must be greater than the
current doc id once the iterator has been initialized.</p>
+
+</li>
+</ul>
+
+<p>Returns: A positive doc id, or 0 once the iterator is exhausted.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Index::PostingList isa <a
href="../../Lucy/Search/Matcher.html">Lucy::Search::Matcher</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/PostingListReader.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/PostingListReader.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/PostingListReader.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,49 @@
+
+<html>
+<head>
+<title>Lucy::Index::PostingListReader - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Index::PostingListReader - Read postings data.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $posting_list_reader
+ = $seg_reader->obtain("Lucy::Index::PostingListReader");
+ my $posting_list = $posting_list_reader->posting_list(
+ field => 'title',
+ term => 'foo',
+ );</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>PostingListReaders produce <a
href="../../Lucy/Index/PostingList.html">PostingList</a> objects which convey
document matching information.</p>
+
+<h1 id="ABSTRACT-METHODS">ABSTRACT METHODS</h1>
+
+<h2 id="posting_list-labeled-params">posting_list( <i>[labeled params]</i>
)</h2>
+
+<p>Returns a PostingList, or undef if either <code>field</code> is undef or
<code>field</code> is not present in any documents.</p>
+
+<ul>
+
+<li><p><b>field</b> - A field name.</p>
+
+</li>
+<li><p><b>term</b> - If supplied, the PostingList will be pre-located to this
term using seek().</p>
+
+</li>
+</ul>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Index::PostingListReader isa <a
href="../../Lucy/Index/DataReader.html">Lucy::Index::DataReader</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/SegReader.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/SegReader.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/SegReader.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,55 @@
+
+<html>
+<head>
+<title>Lucy::Index::SegReader - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Index::SegReader - Single-segment IndexReader.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $polyreader = Lucy::Index::IndexReader->open(
+ index => '/path/to/index',
+ );
+ my $seg_readers = $polyreader->seg_readers;
+ for my $seg_reader (@$seg_readers) {
+ my $seg_name = $seg_reader->get_seg_name;
+ my $num_docs = $seg_reader->doc_max;
+ print "Segment $seg_name ($num_docs documents):\n";
+ my $doc_reader =
$seg_reader->obtain("Lucy::Index::DocReader");
+ for my $doc_id ( 1 .. $num_docs ) {
+ my $doc = $doc_reader->fetch_doc($doc_id);
+ print " $doc_id: $doc->{title}\n";
+ }
+ }</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<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>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="get_seg_name">get_seg_name()</h2>
+
+<p>Return the name of the segment.</p>
+
+<h2 id="get_seg_num">get_seg_num()</h2>
+
+<p>Return the number of the segment.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Index::SegReader isa <a
href="../../Lucy/Index/IndexReader.html">Lucy::Index::IndexReader</a> isa <a
href="../../Lucy/Index/DataReader.html">Lucy::Index::DataReader</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/SegWriter.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/SegWriter.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/SegWriter.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,61 @@
+
+<html>
+<head>
+<title>Lucy::Index::SegWriter - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Index::SegWriter - Write one segment of an index.</p>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<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 add_writer() have
add_inverted_doc() invoked for each document supplied to SegWriter's
add_doc().</p>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="add_doc-labeled-params">add_doc( <i>[labeled params]</i> )</h2>
+
+<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>
+
+<h2 id="add_writer-writer">add_writer(writer)</h2>
+
+<p>Add a DataWriter to the SegWriter's stack of writers.</p>
+
+<h2 id="register-labeled-params">register( <i>[labeled params]</i> )</h2>
+
+<p>Register a DataWriter component with the SegWriter. (Note that registration
simply makes the writer available via fetch(), so you may also want to call
add_writer()).</p>
+
+<ul>
+
+<li><p><b>api</b> - The name of the DataWriter api which <code>writer</code>
implements.</p>
+
+</li>
+<li><p><b>component</b> - A DataWriter.</p>
+
+</li>
+</ul>
+
+<h2 id="fetch-api">fetch(api)</h2>
+
+<p>Retrieve a registered component.</p>
+
+<ul>
+
+<li><p><b>api</b> - The name of the DataWriter api which the component
implements.</p>
+
+</li>
+</ul>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Index::SegWriter isa <a
href="../../Lucy/Index/DataWriter.html">Lucy::Index::DataWriter</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/Segment.html
==============================================================================
--- websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/Segment.html
(added)
+++ websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/Segment.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,122 @@
+
+<html>
+<head>
+<title>Lucy::Index::Segment - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Index::Segment - Warehouse for information about one segment of an
inverted index.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> # Index-time.
+ package MyDataWriter;
+ use base qw( Lucy::Index::DataWriter );
+
+ sub finish {
+ my $self = shift;
+ my $segment = $self->get_segment;
+ my $metadata = $self->SUPER::metadata();
+ $metadata->{foo} = $self->get_foo;
+ $segment->store_metadata(
+ key => 'my_component',
+ metadata => $metadata
+ );
+ }
+
+ # Search-time.
+ package MyDataReader;
+ use base qw( Lucy::Index::DataReader );
+
+ sub new {
+ my $self = shift->SUPER::new(@_);
+ my $segment = $self->get_segment;
+ my $metadata = $segment->fetch_metadata('my_component');
+ if ($metadata) {
+ $self->set_foo( $metadata->{foo} );
+ ...
+ }
+ return $self;
+ }</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<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>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="add_field-field">add_field(field)</h2>
+
+<p>Register a new field and assign it a field number. If the field was already
known, nothing happens.</p>
+
+<ul>
+
+<li><p><b>field</b> - Field name.</p>
+
+</li>
+</ul>
+
+<p>Returns: the field's field number, which is a positive integer.</p>
+
+<h2 id="store_metadata-labeled-params">store_metadata( <i>[labeled params]</i>
)</h2>
+
+<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>
+
+<ul>
+
+<li><p><b>key</b> - String identifying an index component.</p>
+
+</li>
+<li><p><b>metadata</b> - JSON-izable data structure.</p>
+
+</li>
+</ul>
+
+<h2 id="fetch_metadata-key">fetch_metadata(key)</h2>
+
+<p>Fetch a value from the Segment's metadata hash.</p>
+
+<h2 id="field_num-field">field_num(field)</h2>
+
+<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>
+
+<ul>
+
+<li><p><b>field</b> - Field name.</p>
+
+</li>
+</ul>
+
+<h2 id="field_name-field_num">field_name(field_num)</h2>
+
+<p>Given a field number, return the name of its field, or undef if the field
name can't be found.</p>
+
+<h2 id="get_name">get_name()</h2>
+
+<p>Getter for the object's seg name.</p>
+
+<h2 id="get_number">get_number()</h2>
+
+<p>Getter for the segment number.</p>
+
+<h2 id="set_count-count">set_count(count)</h2>
+
+<p>Setter for the object's document count.</p>
+
+<h2 id="get_count">get_count()</h2>
+
+<p>Getter for the object's document count.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Index::Segment isa Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/Similarity.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/Similarity.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/Similarity.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,59 @@
+
+<html>
+<head>
+<title>Lucy::Index::Similarity - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Index::Similarity - Judge how well a document matches a query.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> package MySimilarity;
+
+ sub length_norm { return 1.0 } # disable length normalization
+
+ package MyFullTextType;
+ use base qw( Lucy::Plan::FullTextType );
+
+ sub make_similarity { MySimilarity->new }</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>After determining whether a document matches a given query, a score must be
calculated which indicates how <i>well</i> 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>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new">new()</h2>
+
+<pre><code> my $sim = Lucy::Index::Similarity->new;</code></pre>
+
+<p>Constructor. Takes no arguments.</p>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="length_norm-num_tokens">length_norm(num_tokens)</h2>
+
+<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>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Index::Similarity isa Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/Snapshot.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/Snapshot.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Index/Snapshot.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,99 @@
+
+<html>
+<head>
+<title>Lucy::Index::Snapshot - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Index::Snapshot - Point-in-time index file list.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $snapshot = Lucy::Index::Snapshot->new;
+ $snapshot->read_file( folder => $folder ); # load most recent
snapshot
+ my $files = $snapshot->list;
+ print "$_\n" for @$files;</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<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>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new">new()</h2>
+
+<pre><code> my $snapshot = Lucy::Index::Snapshot->new;</code></pre>
+
+<p>Constructor. Takes no arguments.</p>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="list">list()</h2>
+
+<p>Return an array of all entries.</p>
+
+<h2 id="num_entries">num_entries()</h2>
+
+<p>Return the number of entries (including directories).</p>
+
+<h2 id="add_entry-entry">add_entry(entry)</h2>
+
+<p>Add a filepath to the snapshot.</p>
+
+<h2 id="delete_entry-entry">delete_entry(entry)</h2>
+
+<p>Delete a filepath from the snapshot.</p>
+
+<p>Returns: true if the entry existed and was successfully deleted, false
otherwise.</p>
+
+<h2 id="read_file-labeled-params">read_file( <i>[labeled params]</i> )</h2>
+
+<p>Decode a snapshot file and initialize the object to reflect its
contents.</p>
+
+<ul>
+
+<li><p><b>folder</b> - A Folder.</p>
+
+</li>
+<li><p><b>path</b> - The location of the snapshot file. If not supplied, the
most recent snapshot file in the base directory will be chosen.</p>
+
+</li>
+</ul>
+
+<p>Returns: the object, allowing an assignment idiom.</p>
+
+<h2 id="write_file-labeled-params">write_file( <i>[labeled params]</i> )</h2>
+
+<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>
+
+<ul>
+
+<li><p><b>folder</b> - A Folder.</p>
+
+</li>
+<li><p><b>path</b> - The path of the file to write. If undef, a file name will
be chosen which supersedes the latest snapshot file in the index folder.</p>
+
+</li>
+</ul>
+
+<h2 id="set_path-path">set_path(path)</h2>
+
+<p>Set the path to the file that the Snapshot object serves as a proxy for.</p>
+
+<h2 id="get_path">get_path()</h2>
+
+<p>Get the path to the snapshot file. Initially undef; updated by read_file(),
write_file(), and set_path().</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Index::Snapshot isa Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Object/BitVector.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Object/BitVector.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Object/BitVector.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,179 @@
+
+<html>
+<head>
+<title>Lucy::Object::BitVector - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Object::BitVector - An array of bits.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $bit_vec = Lucy::Object::BitVector->new( capacity => 8
);
+ my $other = Lucy::Object::BitVector->new( capacity => 8 );
+ $bit_vec->set($_) for ( 0, 2, 4, 6 );
+ $other->set($_) for ( 1, 3, 5, 7 );
+ $bit_vec->or($other);
+ print "$_\n" for @{ $bit_vec->to_array }; # prints 0
through 7.</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>BitVector is a growable array of bits. All bits are initially zero.</p>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new-labeled-params">new( <i>[labeled params]</i> )</h2>
+
+<pre><code> my $bit_vec = Lucy::Object::BitVector->new(
+ capacity => $doc_max + 1, # default 0,
+ );</code></pre>
+
+<ul>
+
+<li><p><b>capacity</b> - The number of bits that the initial array should be
able to hold.</p>
+
+</li>
+</ul>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="get-tick">get(tick)</h2>
+
+<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>
+
+<ul>
+
+<li><p><b>tick</b> - The requested bit.</p>
+
+</li>
+</ul>
+
+<h2 id="set-tick">set(tick)</h2>
+
+<p>Set the bit at <code>tick</code> to 1.</p>
+
+<ul>
+
+<li><p><b>tick</b> - The bit to be set.</p>
+
+</li>
+</ul>
+
+<h2 id="clear-tick">clear(tick)</h2>
+
+<p>Clear the indicated bit. (i.e. set it to 0).</p>
+
+<ul>
+
+<li><p><b>tick</b> - The bit to be cleared.</p>
+
+</li>
+</ul>
+
+<h2 id="clear_all">clear_all()</h2>
+
+<p>Clear all bits.</p>
+
+<h2 id="and-other">and(other)</h2>
+
+<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>
+
+<ul>
+
+<li><p><b>other</b> - Another BitVector.</p>
+
+</li>
+</ul>
+
+<h2 id="or-other">or(other)</h2>
+
+<p>Modify the BitVector, setting all bits which are set in the other BitVector
if they were not already set.</p>
+
+<ul>
+
+<li><p><b>other</b> - Another BitVector.</p>
+
+</li>
+</ul>
+
+<h2 id="and_not-other">and_not(other)</h2>
+
+<p>Modify the BitVector, clearing all bits which are set in the other.</p>
+
+<ul>
+
+<li><p><b>other</b> - Another BitVector.</p>
+
+</li>
+</ul>
+
+<h2 id="xor-other">xor(other)</h2>
+
+<p>Modify the BitVector, performing an XOR operation against the other.</p>
+
+<ul>
+
+<li><p><b>other</b> - Another BitVector.</p>
+
+</li>
+</ul>
+
+<h2 id="flip-tick">flip(tick)</h2>
+
+<p>Invert the value of a bit.</p>
+
+<ul>
+
+<li><p><b>tick</b> - The bit to invert.</p>
+
+</li>
+</ul>
+
+<h2 id="flip_block-labeled-params">flip_block( <i>[labeled params]</i> )</h2>
+
+<p>Invert each bit within a contiguous block.</p>
+
+<ul>
+
+<li><p><b>offset</b> - Lower bound.</p>
+
+</li>
+<li><p><b>length</b> - The number of bits to flip.</p>
+
+</li>
+</ul>
+
+<h2 id="next_hit-tick">next_hit(tick)</h2>
+
+<p>Returns the next set bit equal to or greater than <code>tick</code>, or -1
if no such bit exists.</p>
+
+<h2 id="to_array">to_array()</h2>
+
+<p>Return an array where each element represents a set bit.</p>
+
+<h2 id="grow-capacity">grow(capacity)</h2>
+
+<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>
+
+<ul>
+
+<li><p><b>capacity</b> - Least number of bits the BitVector should
accomodate.</p>
+
+</li>
+</ul>
+
+<h2 id="count">count()</h2>
+
+<p>Return a count of the number of set bits.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Object::BitVector isa Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added: websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Object/Err.html
==============================================================================
--- websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Object/Err.html
(added)
+++ websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Object/Err.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,46 @@
+
+<html>
+<head>
+<title></title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Object::Err - Exception.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> use Scalar::Util qw( blessed );
+ my $bg_merger;
+ while (1) {
+ $bg_merger = eval {
+ Lucy::Index::BackgroundMerger->new( index => $index );
+ };
+ last if $bg_merger;
+ if ( blessed($@) and $@->isa("Lucy::Store::LockErr") ) {
+ warn "Retrying...\n";
+ }
+ else {
+ # Re-throw.
+ die "Failed to open BackgroundMerger: $@";
+ }
+ }</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>Most of the time when Lucy encounters an error, it tries to raise a
Lucy::Object::Err exception with an error message and context information.</p>
+
+<p>At present, it is only safe to catch exceptions which are specifically
documented as catchable; most times when an Err is raised, Lucy leaks
memory.</p>
+
+<p>The Err module also provides access to a per-thread Err shared variable via
set_error() and get_error(). It may be used to store an Err object temporarily,
so that calling code may choose how to handle a particular error condition.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Object::Err isa <a
href="../../Lucy/Object/Obj.html">Lucy::Object::Obj</a>.</p>
+
+</body>
+</html>
+
Added: websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Object/Obj.html
==============================================================================
--- websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Object/Obj.html
(added)
+++ websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Object/Obj.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,20 @@
+
+<html>
+<head>
+<title>Lucy::Object::Obj - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Object::Obj - Moved.</p>
+
+<h1 id="MOVED">MOVED</h1>
+
+<p>Lucy::Object::Obj has been moved to Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Plan/Architecture.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Plan/Architecture.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Plan/Architecture.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,101 @@
+
+<html>
+<head>
+<title>Lucy::Plan::Architecture - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Plan::Architecture - Configure major components of an index.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> package MyArchitecture;
+ use base qw( Lucy::Plan::Architecture );
+
+ use LucyX::Index::ZlibDocWriter;
+ use LucyX::Index::ZlibDocReader;
+
+ sub register_doc_writer {
+ my ( $self, $seg_writer ) = @_;
+ my $doc_writer = LucyX::Index::ZlibDocWriter->new(
+ snapshot => $seg_writer->get_snapshot,
+ segment => $seg_writer->get_segment,
+ polyreader => $seg_writer->get_polyreader,
+ );
+ $seg_writer->register(
+ api => "Lucy::Index::DocReader",
+ component => $doc_writer,
+ );
+ $seg_writer->add_writer($doc_writer);
+ }
+
+ sub register_doc_reader {
+ my ( $self, $seg_reader ) = @_;
+ my $doc_reader = LucyX::Index::ZlibDocReader->new(
+ schema => $seg_reader->get_schema,
+ folder => $seg_reader->get_folder,
+ segments => $seg_reader->get_segments,
+ seg_tick => $seg_reader->get_seg_tick,
+ snapshot => $seg_reader->get_snapshot,
+ );
+ $seg_reader->register(
+ api => 'Lucy::Index::DocReader',
+ component => $doc_reader,
+ );
+ }
+
+ package MySchema;
+ use base qw( Lucy::Plan::Schema );
+
+ sub architecture {
+ shift;
+ return MyArchitecture->new(@_);
+ }</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>By default, a Lucy index consists of several main parts: lexicon, postings,
stored documents, deletions, and highlight data. The readers and writers for
that data are spawned by Architecture. Each component operates at the segment
level; Architecture's factory methods are used to build up <a
href="../../Lucy/Index/SegWriter.html">SegWriter</a> and <a
href="../../Lucy/Index/SegReader.html">SegReader</a>.</p>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new">new()</h2>
+
+<pre><code> my $arch = Lucy::Plan::Architecture->new;</code></pre>
+
+<p>Constructor. Takes no arguments.</p>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="register_doc_writer-writer">register_doc_writer(writer)</h2>
+
+<p>Spawn a DataWriter and register() it with the supplied SegWriter, adding it
to the SegWriter's writer stack.</p>
+
+<ul>
+
+<li><p><b>writer</b> - A SegWriter.</p>
+
+</li>
+</ul>
+
+<h2 id="register_doc_reader-reader">register_doc_reader(reader)</h2>
+
+<p>Spawn a DocReader and register() it with the supplied SegReader.</p>
+
+<ul>
+
+<li><p><b>reader</b> - A SegReader.</p>
+
+</li>
+</ul>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Plan::Architecture isa Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Plan/BlobType.html
==============================================================================
--- websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Plan/BlobType.html
(added)
+++ websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Plan/BlobType.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,47 @@
+
+<html>
+<head>
+<title>Lucy::Plan::BlobType - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Plan::BlobType - Default behaviors for binary fields.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $string_type = Lucy::Plan::StringType->new;
+ my $blob_type = Lucy::Plan::BlobType->new( stored => 1 );
+ my $schema = Lucy::Plan::Schema->new;
+ $schema->spec_field( name => 'id', type => $string_type
);
+ $schema->spec_field( name => 'jpeg', type => $blob_type
);</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>BlobType is an implementation of FieldType tuned for use with fields
containing binary data, which cannot be indexed or searched -- only stored.</p>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new-labeled-params">new( <i>[labeled params]</i> )</h2>
+
+<pre><code> my $blob_type = Lucy::Plan::BlobType->new(
+ stored => 1, # default: false
+ );</code></pre>
+
+<ul>
+
+<li><p><b>stored</b> - boolean indicating whether the field should be
stored.</p>
+
+</li>
+</ul>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Plan::BlobType isa <a
href="../../Lucy/Plan/FieldType.html">Lucy::Plan::FieldType</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Plan/FieldType.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Plan/FieldType.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Plan/FieldType.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,69 @@
+
+<html>
+<head>
+<title>Lucy::Plan::FieldType - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Plan::FieldType - Define a field's behavior.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my @sortable;
+ for my $field ( @{ $schema->all_fields } ) {
+ my $type = $schema->fetch_type($field);
+ next unless $type->sortable;
+ push @sortable, $field;
+ }</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>FieldType is an abstract class defining a set of traits and behaviors which
may be associated with one or more field names.</p>
+
+<p>Properties which are common to all field types include <code>boost</code>,
<code>indexed</code>, <code>stored</code>, <code>sortable</code>,
<code>binary</code>, and <code>similarity</code>.</p>
+
+<p>The <code>boost</code> property is a floating point scoring multiplier
which defaults to 1.0. Values greater than 1.0 cause the field to contribute
more to a document's score, lower values, less.</p>
+
+<p>The <code>indexed</code> property indicates whether the field should be
indexed (so that it can be searched).</p>
+
+<p>The <code>stored</code> property indicates whether to store the raw field
value, so that it can be retrieved when a document turns up in a search.</p>
+
+<p>The <code>sortable</code> property indicates whether search results should
be sortable based on the contents of the field.</p>
+
+<p>The <code>binary</code> property indicates whether the field contains
binary or text data. Unlike most other properties, <code>binary</code> is not
settable.</p>
+
+<p>The <code>similarity</code> property is a <a
href="../../Lucy/Index/Similarity.html">Similarity</a> object which defines
matching and scoring behavior for the field. It is required if the field is
<code>indexed</code>.</p>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="get_boost">get_boost()</h2>
+
+<p>Accessor for <code>boost</code>.</p>
+
+<h2 id="indexed">indexed()</h2>
+
+<p>Accessor for <code>indexed</code>.</p>
+
+<h2 id="stored">stored()</h2>
+
+<p>Accessor for <code>stored</code>.</p>
+
+<h2 id="sortable">sortable()</h2>
+
+<p>Accessor for <code>sortable</code>.</p>
+
+<h2 id="binary">binary()</h2>
+
+<p>Indicate whether the field contains binary data.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Plan::FieldType isa Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Plan/FullTextType.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Plan/FullTextType.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Plan/FullTextType.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,85 @@
+
+<html>
+<head>
+<title>Lucy::Plan::FullTextType - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Plan::FullTextType - Full-text search field type.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $easyanalyzer = Lucy::Analysis::EasyAnalyzer->new(
+ language => 'en',
+ );
+ my $type = Lucy::Plan::FullTextType->new(
+ analyzer => $easyanalyzer,
+ );
+ my $schema = Lucy::Plan::Schema->new;
+ $schema->spec_field( name => 'title', type => $type );
+ $schema->spec_field( name => 'content', type => $type
);</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>Lucy::Plan::FullTextType is an implementation of <a
href="../../Lucy/Plan/FieldType.html">Lucy::Plan::FieldType</a> tuned for
"full text search".</p>
+
+<p>Full text fields are associated with an <a
href="../../Lucy/Analysis/Analyzer.html">Analyzer</a>, which is used to
tokenize and normalize the text so that it can be searched for individual
words.</p>
+
+<p>For an exact-match, single value field type using character data, see <a
href="../../Lucy/Plan/StringType.html">StringType</a>.</p>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new-labeled-params">new( <i>[labeled params]</i> )</h2>
+
+<pre><code> my $type = Lucy::Plan::FullTextType->new(
+ analyzer => $analyzer, # required
+ boost => 2.0, # default: 1.0
+ indexed => 1, # default: true
+ stored => 1, # default: true
+ sortable => 1, # default: false
+ highlightable => 1, # default: false
+ );</code></pre>
+
+<ul>
+
+<li><p><b>analyzer</b> - An Analyzer.</p>
+
+</li>
+<li><p><b>boost</b> - floating point per-field boost.</p>
+
+</li>
+<li><p><b>indexed</b> - boolean indicating whether the field should be
indexed.</p>
+
+</li>
+<li><p><b>stored</b> - boolean indicating whether the field should be
stored.</p>
+
+</li>
+<li><p><b>sortable</b> - boolean indicating whether the field should be
sortable.</p>
+
+</li>
+<li><p><b>highlightable</b> - boolean indicating whether the field should be
highlightable.</p>
+
+</li>
+</ul>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="set_highlightable-highlightable">set_highlightable(highlightable)</h2>
+
+<p>Indicate whether to store data required by <a
href="../../Lucy/Highlight/Highlighter.html">Lucy::Highlight::Highlighter</a>
for excerpt selection and search term highlighting.</p>
+
+<h2 id="highlightable">highlightable()</h2>
+
+<p>Accessor for "highlightable" property.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Plan::FullTextType isa Lucy::Plan::TextType isa <a
href="../../Lucy/Plan/FieldType.html">Lucy::Plan::FieldType</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added: websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Plan/Schema.html
==============================================================================
--- websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Plan/Schema.html
(added)
+++ websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Plan/Schema.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,96 @@
+
+<html>
+<head>
+<title>Lucy::Plan::Schema - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Plan::Schema - User-created specification for an inverted index.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> use Lucy::Plan::Schema;
+ use Lucy::Plan::FullTextType;
+ use Lucy::Analysis::EasyAnalyzer;
+
+ my $schema = Lucy::Plan::Schema->new;
+ my $easyanalyzer = Lucy::Analysis::EasyAnalyzer->new(
+ language => 'en',
+ );
+ my $type = Lucy::Plan::FullTextType->new(
+ analyzer => $easyanalyzer,
+ );
+ $schema->spec_field( name => 'title', type => $type );
+ $schema->spec_field( name => 'content', type => $type
);</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>A Schema is a specification which indicates how other entities should
interpret the raw data in an inverted index and interact with it.</p>
+
+<p>Once an actual index has been created using a particular Schema, existing
field definitions may not be changed. However, it is possible to add new fields
during subsequent indexing sessions.</p>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new">new()</h2>
+
+<pre><code> my $schema = Lucy::Plan::Schema->new;</code></pre>
+
+<p>Constructor. Takes no arguments.</p>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="spec_field-labeled-params">spec_field( <i>[labeled params]</i> )</h2>
+
+<p>Define the behavior of a field by associating it with a FieldType.</p>
+
+<p>If this method has already been called for the supplied <code>field</code>,
it will merely test to verify that the supplied FieldType equals() the existing
one.</p>
+
+<ul>
+
+<li><p><b>name</b> - The name of the field.</p>
+
+</li>
+<li><p><b>type</b> - A FieldType.</p>
+
+</li>
+</ul>
+
+<h2 id="num_fields">num_fields()</h2>
+
+<p>Return the number of fields currently defined.</p>
+
+<h2 id="all_fields">all_fields()</h2>
+
+<p>Return all the Schema's field names as an array.</p>
+
+<h2 id="fetch_type-field">fetch_type(field)</h2>
+
+<p>Return the FieldType for the specified field. If the field can't be
found, return undef.</p>
+
+<h2 id="fetch_sim-field">fetch_sim(field)</h2>
+
+<p>Return the Similarity for the specified field, or undef if either the field
can't be found or it isn't associated with a Similarity.</p>
+
+<h2 id="architecture">architecture()</h2>
+
+<p>Factory method which creates an Architecture object for this index.</p>
+
+<h2 id="get_architecture">get_architecture()</h2>
+
+<p>Return the Schema instance's internal Architecture object.</p>
+
+<h2 id="get_similarity">get_similarity()</h2>
+
+<p>Return the Schema instance's internal Similarity object.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Plan::Schema isa Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Plan/StringType.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Plan/StringType.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Plan/StringType.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,57 @@
+
+<html>
+<head>
+<title>Lucy::Plan::StringType - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Plan::StringType - Non-tokenized text type.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $type = Lucy::Plan::StringType->new;
+ my $schema = Lucy::Plan::Schema->new;
+ $schema->spec_field( name => 'category', type => $type
);</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>Lucy::Plan::StringType is used for "exact-match" strings.</p>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new">new()</h2>
+
+<pre><code> my $type = Lucy::Plan::StringType->new(
+ boost => 0.1, # default: 1.0
+ indexed => 1, # default: true
+ stored => 1, # default: true
+ sortable => 1, # default: false
+ );</code></pre>
+
+<ul>
+
+<li><p><b>boost</b> - floating point per-field boost.</p>
+
+</li>
+<li><p><b>indexed</b> - boolean indicating whether the field should be
indexed.</p>
+
+</li>
+<li><p><b>stored</b> - boolean indicating whether the field should be
stored.</p>
+
+</li>
+<li><p><b>sortable</b> - boolean indicating whether the field should be
sortable.</p>
+
+</li>
+</ul>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Plan::StringType isa Lucy::Plan::TextType isa <a
href="../../Lucy/Plan/FieldType.html">Lucy::Plan::FieldType</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/ANDQuery.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/ANDQuery.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/ANDQuery.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,53 @@
+
+<html>
+<head>
+<title>Lucy::Search::ANDQuery - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Search::ANDQuery - Intersect multiple result sets.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $foo_and_bar_query = Lucy::Search::ANDQuery->new(
+ children => [ $foo_query, $bar_query ],
+ );
+ my $hits = $searcher->hits( query => $foo_and_bar_query );
+ ...</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>ANDQuery is a composite <a href="../../Lucy/Search/Query.html">Query</a>
which matches only when all of its children match, so its result set is the
intersection of their result sets. Documents which match receive a summed
score.</p>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new-labeled-params">new( <i>[labeled params]</i> )</h2>
+
+<pre><code> my $foo_and_bar_query = Lucy::Search::ANDQuery->new(
+ children => [ $foo_query, $bar_query ],
+ );</code></pre>
+
+<ul>
+
+<li><p><b>children</b> - An array of child Queries.</p>
+
+</li>
+</ul>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="add_child-query">add_child(query)</h2>
+
+<p>Add a child Query node.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Search::ANDQuery isa <a
href="../../Lucy/Search/PolyQuery.html">Lucy::Search::PolyQuery</a> isa <a
href="../../Lucy/Search/Query.html">Lucy::Search::Query</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/Collector.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/Collector.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/Collector.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,59 @@
+
+<html>
+<head>
+<title>Lucy::Search::Collector - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Search::Collector - Process hits.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> # Abstract base class.</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>A Collector decides what to do with the hits that a <a
href="../../Lucy/Search/Matcher.html">Matcher</a> iterates through, based on
how the abstract collect() method is implemented.</p>
+
+<p>Collectors operate on individual segments, but must operate within the
context of a larger collection. Each time the collector moves to a new segment,
set_reader(), set_base() and set_matcher() will be called, and the collector
must take the updated information into account.</p>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new">new()</h2>
+
+<pre><code> package MyCollector;
+ use base qw( Lucy::Search::Collector );
+ our %foo;
+ sub new {
+ my $self = shift->SUPER::new;
+ my %args = @_;
+ $foo{$$self} = $args{foo};
+ return $self;
+ }</code></pre>
+
+<p>Abstract constructor. Takes no arguments.</p>
+
+<h1 id="ABSTRACT-METHODS">ABSTRACT METHODS</h1>
+
+<h2 id="collect-doc_id">collect(doc_id)</h2>
+
+<p>Do something with a doc id. (For instance, keep track of the docs with the
ten highest scores.)</p>
+
+<ul>
+
+<li><p><b>doc_id</b> - A segment document id.</p>
+
+</li>
+</ul>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Search::Collector isa Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/Collector/BitCollector.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/Collector/BitCollector.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/Collector/BitCollector.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,58 @@
+
+<html>
+<head>
+<title>Lucy::Search::Collector::BitCollector - Apache Lucy Perl
Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Search::Collector::BitCollector - Collector which records doc nums in
a BitVector.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $bit_vec = Lucy::Object::BitVector->new(
+ capacity => $searcher->doc_max + 1,
+ );
+ my $bit_collector = Lucy::Search::Collector::BitCollector->new(
+ bit_vector => $bit_vec,
+ );
+ $searcher->collect(
+ collector => $bit_collector,
+ query => $query,
+ );</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>BitCollector is a Collector which saves matching document ids in a <a
href="../../../Lucy/Object/BitVector.html">BitVector</a>. It is useful for
recording the entire set of documents which matches a query.</p>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new-labeled-params">new( <i>[labeled params]</i> )</h2>
+
+<pre><code> my $bit_collector =
Lucy::Search::Collector::BitCollector->new(
+ bit_vector => $bit_vec, # required
+ );</code></pre>
+
+<ul>
+
+<li><p><b>bit_vector</b> - A Lucy::Object::BitVector.</p>
+
+</li>
+</ul>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="collect-doc_id">collect(doc_id)</h2>
+
+<p>Set bit in the object's BitVector for the supplied doc id.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Search::Collector::BitCollector isa <a
href="../../../Lucy/Search/Collector.html">Lucy::Search::Collector</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/Compiler.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/Compiler.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/Compiler.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,152 @@
+
+<html>
+<head>
+<title>Lucy::Search::Compiler - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Search::Compiler - Query-to-Matcher compiler.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> # (Compiler is an abstract base class.)
+ package MyCompiler;
+ use base qw( Lucy::Search::Compiler );
+
+ sub make_matcher {
+ my $self = shift;
+ return MyMatcher->new( @_, compiler => $self );
+ }</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>The purpose of the Compiler class is to take a specification in the form of
a <a href="../../Lucy/Search/Query.html">Query</a> object and compile a <a
href="../../Lucy/Search/Matcher.html">Matcher</a> object that can do real
work.</p>
+
+<p>The simplest Compiler subclasses -- such as those associated with
constant-scoring Query types -- might simply implement a make_matcher() method
which passes along information verbatim from the Query to the Matcher's
constructor.</p>
+
+<p>However it is common for the Compiler to perform some calculations which
affect it's "weight" -- a floating point multiplier that the
Matcher will factor into each document's score. If that is the case, then
the Compiler subclass may wish to override get_weight(),
sum_of_squared_weights(), and apply_norm_factor().</p>
+
+<p>Compiling a Matcher is a two stage process.</p>
+
+<p>The first stage takes place during the Compiler's construction, which
is where the Query object meets a <a
href="../../Lucy/Search/Searcher.html">Searcher</a> object for the first time.
Searchers operate on a specific document collection and they can tell you
certain statistical information about the collection -- such as how many total
documents are in the collection, or how many documents in the collection a
particular term is present in. Lucy's core Compiler classes plug this
information into the classic TF/IDF weighting algorithm to adjust the
Compiler's weight; custom subclasses might do something similar.</p>
+
+<p>The second stage of compilation is make_matcher(), method, which is where
the Compiler meets a <a href="../../Lucy/Index/SegReader.html">SegReader</a>
object. SegReaders are associated with a single segment within a single index
on a single machine, and are thus lower-level than Searchers, which may
represent a document collection spread out over a search cluster (comprising
several indexes and many segments). The Compiler object can use new information
supplied by the SegReader -- such as whether a term is missing from the local
index even though it is present within the larger collection represented by the
Searcher -- when figuring out what to feed to the Matchers's constructor,
or whether make_matcher() should return a Matcher at all.</p>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new-labeled-params">new( <i>[labeled params]</i> )</h2>
+
+<pre><code> my $compiler = MyCompiler->SUPER::new(
+ parent => $my_query,
+ searcher => $searcher,
+ similarity => $sim, # default: undef
+ boost => undef, # default: see below
+ );</code></pre>
+
+<p>Abstract constructor.</p>
+
+<ul>
+
+<li><p><b>parent</b> - The parent Query.</p>
+
+</li>
+<li><p><b>searcher</b> - A Lucy::Search::Searcher, such as an
IndexSearcher.</p>
+
+</li>
+<li><p><b>similarity</b> - A Similarity.</p>
+
+</li>
+<li><p><b>boost</b> - An arbitrary scoring multiplier. Defaults to the boost
of the parent Query.</p>
+
+</li>
+</ul>
+
+<h1 id="ABSTRACT-METHODS">ABSTRACT METHODS</h1>
+
+<h2 id="make_matcher-labeled-params">make_matcher( <i>[labeled params]</i>
)</h2>
+
+<p>Factory method returning a Matcher.</p>
+
+<ul>
+
+<li><p><b>reader</b> - A SegReader.</p>
+
+</li>
+<li><p><b>need_score</b> - Indicate whether the Matcher must implement
score().</p>
+
+</li>
+</ul>
+
+<p>Returns: a Matcher, or undef if the Matcher would have matched no
documents.</p>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="get_weight">get_weight()</h2>
+
+<p>Return the Compiler's numerical weight, a scoring multiplier. By
default, returns the object's boost.</p>
+
+<h2 id="sum_of_squared_weights">sum_of_squared_weights()</h2>
+
+<p>Compute and return a raw weighting factor. (This quantity is used by
normalize()). By default, simply returns 1.0.</p>
+
+<h2 id="apply_norm_factor-factor">apply_norm_factor(factor)</h2>
+
+<p>Apply a floating point normalization multiplier. For a TermCompiler, this
involves multiplying its own weight by the supplied factor; combining classes
such as ORCompiler would apply the factor recursively to their children.</p>
+
+<p>The default implementation is a no-op; subclasses may wish to multiply
their internal weight by the supplied factor.</p>
+
+<ul>
+
+<li><p><b>factor</b> - The multiplier.</p>
+
+</li>
+</ul>
+
+<h2 id="normalize">normalize()</h2>
+
+<p>Take a newly minted Compiler object and apply query-specific normalization
factors. Should be invoked by Query subclasses during make_compiler() for
top-level nodes.</p>
+
+<p>For a TermQuery, the scoring formula is approximately:</p>
+
+<pre><code> (tf_d * idf_t / norm_d) * (tf_q * idf_t / norm_q)</code></pre>
+
+<p>normalize() is theoretically concerned with applying the second half of
that formula to a the Compiler's weight. What actually happens depends on
how the Compiler and Similarity methods called internally are implemented.</p>
+
+<h2 id="get_parent">get_parent()</h2>
+
+<p>Accessor for the Compiler's parent Query object.</p>
+
+<h2 id="get_similarity">get_similarity()</h2>
+
+<p>Accessor for the Compiler's Similarity object.</p>
+
+<h2 id="highlight_spans-labeled-params">highlight_spans( <i>[labeled
params]</i> )</h2>
+
+<p>Return an array of Span objects, indicating where in the given field the
text that matches the parent Query occurs and how well each snippet matches.
The Span's offset and length are measured in Unicode code points.</p>
+
+<p>The default implementation returns an empty array.</p>
+
+<ul>
+
+<li><p><b>searcher</b> - A Searcher.</p>
+
+</li>
+<li><p><b>doc_vec</b> - A DocVector.</p>
+
+</li>
+<li><p><b>field</b> - The name of the field.</p>
+
+</li>
+</ul>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Search::Compiler isa <a
href="../../Lucy/Search/Query.html">Lucy::Search::Query</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added: websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/Hits.html
==============================================================================
--- websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/Hits.html
(added)
+++ websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/Hits.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,45 @@
+
+<html>
+<head>
+<title>Lucy::Search::Hits - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Search::Hits - Access search results.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $hits = $searcher->hits(
+ query => $query,
+ offset => 0,
+ num_wanted => 10,
+ );
+ while ( my $hit = $hits->next ) {
+ print "<p>$hit->{title} <em>" .
$hit->get_score . "</em></p>\n";
+ }</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>Hits objects are iterators used to access the results of a search.</p>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="next">next()</h2>
+
+<p>Return the next hit, or undef when the iterator is exhausted.</p>
+
+<h2 id="total_hits">total_hits()</h2>
+
+<p>Return the total number of documents which matched the Query used to
produce the Hits object. Note that this is the total number of matches, not
just the number of matches represented by the Hits iterator.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Search::Hits isa Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/IndexSearcher.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/IndexSearcher.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/IndexSearcher.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,125 @@
+
+<html>
+<head>
+<title>Lucy::Search::IndexSearcher - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Search::IndexSearcher - Execute searches against a single index.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $searcher = Lucy::Search::IndexSearcher->new(
+ index => '/path/to/index'
+ );
+ my $hits = $searcher->hits(
+ query => 'foo bar',
+ offset => 0,
+ num_wanted => 100,
+ );</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>Use the IndexSearcher class to perform search queries against an index.
(For searching multiple indexes at once, see <a
href="../../Lucy/Search/PolySearcher.html">PolySearcher</a>).</p>
+
+<p>IndexSearchers operate against a single point-in-time view or <a
href="../../Lucy/Index/Snapshot.html">Snapshot</a> of the index. If an index is
modified, a new IndexSearcher must be opened to access the changes.</p>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new-labeled-params">new( <i>[labeled params]</i> )</h2>
+
+<pre><code> my $searcher = Lucy::Search::IndexSearcher->new(
+ index => '/path/to/index'
+ );</code></pre>
+
+<ul>
+
+<li><p><b>index</b> - Either a string filepath, a Folder, or an
IndexReader.</p>
+
+</li>
+</ul>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="hits-labeled-params">hits( <i>[labeled params]</i> )</h2>
+
+<p>Return a Hits object containing the top results.</p>
+
+<ul>
+
+<li><p><b>query</b> - Either a Query object or a query string.</p>
+
+</li>
+<li><p><b>offset</b> - 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>
+
+</li>
+<li><p><b>num_wanted</b> - The number of hits you would like to see after
<code>offset</code> is taken into account.</p>
+
+</li>
+<li><p><b>sort_spec</b> - A <a
href="../../Lucy/Search/SortSpec.html">Lucy::Search::SortSpec</a>, which will
affect how results are ranked and returned.</p>
+
+</li>
+</ul>
+
+<h2 id="collect-labeled-params">collect( <i>[labeled params]</i> )</h2>
+
+<p>Iterate over hits, feeding them into a <a
href="../../Lucy/Search/Collector.html">Collector</a>.</p>
+
+<ul>
+
+<li><p><b>query</b> - A Query.</p>
+
+</li>
+<li><p><b>collector</b> - A Collector.</p>
+
+</li>
+</ul>
+
+<h2 id="doc_max">doc_max()</h2>
+
+<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>
+
+<h2 id="doc_freq-labeled-params">doc_freq( <i>[labeled params]</i> )</h2>
+
+<p>Return the number of documents which contain the term in the given
field.</p>
+
+<ul>
+
+<li><p><b>field</b> - Field name.</p>
+
+</li>
+<li><p><b>term</b> - The term to look up.</p>
+
+</li>
+</ul>
+
+<h2 id="fetch_doc-doc_id">fetch_doc(doc_id)</h2>
+
+<p>Retrieve a document. Throws an error if the doc id is out of range.</p>
+
+<ul>
+
+<li><p><b>doc_id</b> - A document id.</p>
+
+</li>
+</ul>
+
+<h2 id="get_schema">get_schema()</h2>
+
+<p>Accessor for the object's <code>schema</code> member.</p>
+
+<h2 id="get_reader">get_reader()</h2>
+
+<p>Accessor for the object's <code>reader</code> member.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Search::IndexSearcher isa <a
href="../../Lucy/Search/Searcher.html">Lucy::Search::Searcher</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/LeafQuery.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/LeafQuery.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/LeafQuery.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,71 @@
+
+<html>
+<head>
+<title>Lucy::Search::LeafQuery - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Search::LeafQuery - Leaf node in a tree created by QueryParser.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> package MyQueryParser;
+ use base qw( Lucy::Search::QueryParser );
+
+ sub expand_leaf {
+ my ( $self, $leaf_query ) = @_;
+ if ( $leaf_query->get_text =~ /.\*\s*$/ ) {
+ return PrefixQuery->new(
+ query_string => $leaf_query->get_text,
+ field => $leaf_query->get_field,
+ );
+ }
+ else {
+ return $self->SUPER::expand_leaf($leaf_query);
+ }
+ }</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>LeafQuery objects serve as leaf nodes in the tree structure generated by <a
href="../../Lucy/Search/QueryParser.html">QueryParser</a>'s tree() method.
Ultimately, they must be transformed, typically into either <a
href="../../Lucy/Search/TermQuery.html">TermQuery</a> or <a
href="../../Lucy/Search/PhraseQuery.html">PhraseQuery</a> objects, as
attempting to search a LeafQuery causes an error.</p>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new-labeled-params">new( <i>[labeled params]</i> )</h2>
+
+<pre><code> my $leaf_query = Lucy::Search::LeafQuery->new(
+ text => '"three blind mice"', # required
+ field => 'content', # default: undef
+ );</code></pre>
+
+<ul>
+
+<li><p><b>field</b> - Optional field name.</p>
+
+</li>
+<li><p><b>text</b> - Raw query text.</p>
+
+</li>
+</ul>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="get_field">get_field()</h2>
+
+<p>Accessor for object's <code>field</code> attribute.</p>
+
+<h2 id="get_text">get_text()</h2>
+
+<p>Accessor for object's <code>text</code> attribute.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Search::LeafQuery isa <a
href="../../Lucy/Search/Query.html">Lucy::Search::Query</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/MatchAllQuery.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/MatchAllQuery.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/MatchAllQuery.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,32 @@
+
+<html>
+<head>
+<title>Lucy::Search::MatchAllQuery - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Search::MatchAllQuery - Query which matches all documents.</p>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<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>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new">new()</h2>
+
+<pre><code> my $match_all_query =
Lucy::Search::MatchAllQuery->new;</code></pre>
+
+<p>Constructor. Takes no arguments.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Search::MatchAllQuery isa <a
href="../../Lucy/Search/Query.html">Lucy::Search::Query</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/Matcher.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/Matcher.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/Matcher.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,69 @@
+
+<html>
+<head>
+<title>Lucy::Search::Matcher - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Search::Matcher - Match a set of document ids.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> # abstract base class</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>A Matcher iterates over a set of ascending document ids. Some Matchers
implement score() and can assign relevance scores to the docs that they match.
Other implementations may be match-only.</p>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new">new()</h2>
+
+<pre><code> my $matcher = MyMatcher->SUPER::new;</code></pre>
+
+<p>Abstract constructor.</p>
+
+<h1 id="ABSTRACT-METHODS">ABSTRACT METHODS</h1>
+
+<h2 id="next">next()</h2>
+
+<p>Proceed to the next doc id.</p>
+
+<p>Returns: A positive doc id, or 0 once the iterator is exhausted.</p>
+
+<h2 id="get_doc_id">get_doc_id()</h2>
+
+<p>Return the current doc id. Valid only after a successful call to next() or
advance() and must not be called otherwise.</p>
+
+<h2 id="score">score()</h2>
+
+<p>Return the score of the current document.</p>
+
+<p>Only Matchers which are used for scored search need implement score().</p>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="advance-target">advance(target)</h2>
+
+<p>Advance the iterator to the first doc id greater than or equal to
<code>target</code>. The default implementation simply calls next() over and
over, but subclasses have the option of doing something more efficient.</p>
+
+<ul>
+
+<li><p><b>target</b> - A positive doc id, which must be greater than the
current doc id once the iterator has been initialized.</p>
+
+</li>
+</ul>
+
+<p>Returns: A positive doc id, or 0 once the iterator is exhausted.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Search::Matcher isa Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/NOTQuery.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/NOTQuery.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/NOTQuery.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,62 @@
+
+<html>
+<head>
+<title>Lucy::Search::NOTQuery - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Search::NOTQuery - Invert the result set of another Query.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $not_bar_query = Lucy::Search::NOTQuery->new(
+ negated_query => $bar_query,
+ );
+ my $foo_and_not_bar_query = Lucy::Search::ANDQuery->new(
+ children => [ $foo_query, $not_bar_query ].
+ );
+ my $hits = $searcher->hits( query => $foo_and_not_bar_query );
+ ...</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<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>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new-labeled-params">new( <i>[labeled params]</i> )</h2>
+
+<pre><code> my $not_query = Lucy::Search::NOTQuery->new(
+ negated_query => $query,
+ );</code></pre>
+
+<ul>
+
+<li><p><b>negated_query</b> - The Query whose result set should be
inverted.</p>
+
+</li>
+</ul>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="get_negated_query">get_negated_query()</h2>
+
+<p>Accessor for the object's negated query.</p>
+
+<h2 id="set_negated_query-negated_query">set_negated_query(negated_query)</h2>
+
+<p>Setter for the object's negated query.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Search::NOTQuery isa <a
href="../../Lucy/Search/PolyQuery.html">Lucy::Search::PolyQuery</a> isa <a
href="../../Lucy/Search/Query.html">Lucy::Search::Query</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/NoMatchQuery.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/NoMatchQuery.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/NoMatchQuery.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,32 @@
+
+<html>
+<head>
+<title>Lucy::Search::NoMatchQuery - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Search::NoMatchQuery - Query which matches no documents.</p>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<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>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new">new()</h2>
+
+<pre><code> my $no_match_query =
Lucy::Search::NoMatchQuery->new;</code></pre>
+
+<p>Constructor. Takes no arguments.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Search::NoMatchQuery isa <a
href="../../Lucy/Search/Query.html">Lucy::Search::Query</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/ORQuery.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/ORQuery.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/ORQuery.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,53 @@
+
+<html>
+<head>
+<title>Lucy::Search::ORQuery - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Search::ORQuery - Union multiple result sets.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $foo_or_bar_query = Lucy::Search::ORQuery->new(
+ children => [ $foo_query, $bar_query ],
+ );
+ my $hits = $searcher->hits( query => $foo_or_bar_query );
+ ...</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<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>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new-labeled-params">new( <i>[labeled params]</i> )</h2>
+
+<pre><code> my $foo_or_bar_query = Lucy::Search::ORQuery->new(
+ children => [ $foo_query, $bar_query ],
+ );</code></pre>
+
+<ul>
+
+<li><p><b>children</b> - An array of child Queries.</p>
+
+</li>
+</ul>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="add_child-query">add_child(query)</h2>
+
+<p>Add a child Query node.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Search::ORQuery isa <a
href="../../Lucy/Search/PolyQuery.html">Lucy::Search::PolyQuery</a> isa <a
href="../../Lucy/Search/Query.html">Lucy::Search::Query</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
Added:
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/PhraseQuery.html
==============================================================================
---
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/PhraseQuery.html
(added)
+++
websites/staging/lucy/trunk/content/docs/0.4.0/perl/Lucy/Search/PhraseQuery.html
Mon Apr 4 09:23:00 2016
@@ -0,0 +1,56 @@
+
+<html>
+<head>
+<title>Lucy::Search::PhraseQuery - Apache Lucy Perl Documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+</head>
+<body>
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>Lucy::Search::PhraseQuery - Query matching an ordered list of terms.</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<pre><code> my $phrase_query = Lucy::Search::PhraseQuery->new(
+ field => 'content',
+ terms => [qw( the who )],
+ );
+ my $hits = $searcher->hits( query => $phrase_query );</code></pre>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p>PhraseQuery is a subclass of <a
href="../../Lucy/Search/Query.html">Lucy::Search::Query</a> for matching
against an ordered sequence of terms.</p>
+
+<h1 id="CONSTRUCTORS">CONSTRUCTORS</h1>
+
+<h2 id="new-labeled-params">new( <i>[labeled params]</i> )</h2>
+
+<ul>
+
+<li><p><b>field</b> - The field that the phrase must occur in.</p>
+
+</li>
+<li><p><b>terms</b> - The ordered array of terms that must match.</p>
+
+</li>
+</ul>
+
+<h1 id="METHODS">METHODS</h1>
+
+<h2 id="get_field">get_field()</h2>
+
+<p>Accessor for object's field attribute.</p>
+
+<h2 id="get_terms">get_terms()</h2>
+
+<p>Accessor for object's array of terms.</p>
+
+<h1 id="INHERITANCE">INHERITANCE</h1>
+
+<p>Lucy::Search::PhraseQuery isa <a
href="../../Lucy/Search/Query.html">Lucy::Search::Query</a> isa
Clownfish::Obj.</p>
+
+</body>
+</html>
+
