Add Markdown links with custom URL scheme
Project: http://git-wip-us.apache.org/repos/asf/lucy/repo Commit: http://git-wip-us.apache.org/repos/asf/lucy/commit/500e7ae7 Tree: http://git-wip-us.apache.org/repos/asf/lucy/tree/500e7ae7 Diff: http://git-wip-us.apache.org/repos/asf/lucy/diff/500e7ae7 Branch: refs/heads/master Commit: 500e7ae7117978657d00a7c28334bcf7a004d8db Parents: 1b37039 Author: Nick Wellnhofer <[email protected]> Authored: Mon Nov 10 00:47:29 2014 +0100 Committer: Nick Wellnhofer <[email protected]> Committed: Wed Dec 24 14:43:31 2014 +0100 ---------------------------------------------------------------------- core/Lucy/Analysis/Analyzer.cfh | 8 +++--- core/Lucy/Analysis/CaseFolder.cfh | 2 +- core/Lucy/Analysis/EasyAnalyzer.cfh | 6 ++--- core/Lucy/Analysis/Normalizer.cfh | 2 +- core/Lucy/Analysis/PolyAnalyzer.cfh | 12 ++++----- core/Lucy/Analysis/SnowballStemmer.cfh | 2 +- core/Lucy/Analysis/Token.cfh | 2 +- core/Lucy/Docs/FileLocking.cfh | 6 ++--- core/Lucy/Highlight/Highlighter.cfh | 10 ++++---- core/Lucy/Index/BackgroundMerger.cfh | 10 ++++---- core/Lucy/Index/DataReader.cfh | 2 +- core/Lucy/Index/DataWriter.cfh | 6 ++--- core/Lucy/Index/DeletionsWriter.cfh | 2 +- core/Lucy/Index/DocReader.cfh | 2 +- core/Lucy/Index/IndexManager.cfh | 2 +- core/Lucy/Index/IndexReader.cfh | 10 ++++---- core/Lucy/Index/Indexer.cfh | 30 +++++++++++------------ core/Lucy/Index/Inverter.cfh | 6 ++--- core/Lucy/Index/Lexicon.cfh | 2 +- core/Lucy/Index/PolyReader.cfh | 10 ++++---- core/Lucy/Index/Posting.cfh | 4 +-- core/Lucy/Index/Posting/RichPosting.cfh | 6 ++--- core/Lucy/Index/PostingList.cfh | 2 +- core/Lucy/Index/PostingListReader.cfh | 4 +-- core/Lucy/Index/SegPostingList.cfh | 2 +- core/Lucy/Index/SegReader.cfh | 2 +- core/Lucy/Index/SegWriter.cfh | 20 +++++++-------- core/Lucy/Index/Snapshot.cfh | 4 +-- core/Lucy/Plan/Architecture.cfh | 30 +++++++++++------------ core/Lucy/Plan/FieldType.cfh | 4 +-- core/Lucy/Plan/FullTextType.cfh | 8 +++--- core/Lucy/Plan/Schema.cfh | 2 +- core/Lucy/Search/ANDQuery.cfh | 2 +- core/Lucy/Search/Collector.cfh | 12 ++++----- core/Lucy/Search/Collector/SortCollector.cfh | 2 +- core/Lucy/Search/Compiler.cfh | 26 ++++++++++---------- core/Lucy/Search/IndexSearcher.cfh | 4 +-- core/Lucy/Search/LeafQuery.cfh | 6 ++--- core/Lucy/Search/Matcher.cfh | 8 +++--- core/Lucy/Search/NOTQuery.cfh | 4 +-- core/Lucy/Search/NoMatchQuery.cfh | 2 +- core/Lucy/Search/ORMatcher.cfh | 2 +- core/Lucy/Search/ORQuery.cfh | 2 +- core/Lucy/Search/PhraseQuery.cfh | 2 +- core/Lucy/Search/PolyQuery.cfh | 8 +++--- core/Lucy/Search/Query.cfh | 14 +++++------ core/Lucy/Search/QueryParser.cfh | 30 +++++++++++------------ core/Lucy/Search/Searcher.cfh | 8 +++--- core/Lucy/Search/SortRule.cfh | 2 +- core/Lucy/Search/SortSpec.cfh | 2 +- core/Lucy/Search/TermQuery.cfh | 2 +- core/Lucy/Store/DirHandle.cfh | 4 +-- core/Lucy/Store/FSFolder.cfh | 2 +- core/Lucy/Store/FileHandle.cfh | 2 +- core/Lucy/Store/Folder.cfh | 4 +-- core/Lucy/Store/InStream.cfh | 4 +-- core/Lucy/Store/Lock.cfh | 14 +++++------ core/Lucy/Store/LockFactory.cfh | 12 ++++----- core/Lucy/Store/RAMFolder.cfh | 2 +- core/Lucy/Store/SharedLock.cfh | 12 ++++----- core/Lucy/Test/Plan/TestArchitecture.cfh | 2 +- core/Lucy/Test/TestSchema.cfh | 2 +- core/Lucy/Util/Debug.cfh | 2 +- core/Lucy/Util/Freezer.cfh | 2 +- core/Lucy/Util/PriorityQueue.cfh | 4 +-- core/Lucy/Util/SortExternal.cfh | 16 ++++++------ core/Lucy/Util/Stepper.cfh | 4 +-- core/LucyX/Search/MockMatcher.cfh | 2 +- core/LucyX/Search/ProximityQuery.cfh | 2 +- 69 files changed, 225 insertions(+), 225 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Analysis/Analyzer.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Analysis/Analyzer.cfh b/core/Lucy/Analysis/Analyzer.cfh index 486ebc2..21b8d67 100644 --- a/core/Lucy/Analysis/Analyzer.cfh +++ b/core/Lucy/Analysis/Analyzer.cfh @@ -20,16 +20,16 @@ parcel Lucy; * * An Analyzer is a filter which processes text, transforming it from one form * into another. For instance, an analyzer might break up a long text into - * smaller pieces (L<RegexTokenizer|Lucy::Analysis::RegexTokenizer>), or it + * smaller pieces ([](cfish:RegexTokenizer)), or it * might perform case folding to facilitate case-insensitive search - * (L<Normalizer|Lucy::Analysis::Normalizer>). + * ([](cfish:Normalizer)). */ public abstract class Lucy::Analysis::Analyzer inherits Clownfish::Obj { public inert Analyzer* init(Analyzer *self); - /** Take a single L<Inversion|Lucy::Analysis::Inversion> as input + /** Take a single [](cfish:Inversion) as input * and returns an Inversion, either the same one (presumably transformed * in some way), or a new one. */ @@ -38,7 +38,7 @@ public abstract class Lucy::Analysis::Analyzer inherits Clownfish::Obj { /** Kick off an analysis chain, creating an Inversion from string input. * The default implementation simply creates an initial Inversion with a - * single Token, then calls Transform(), but occasionally subclasses will + * single Token, then calls [](cfish:.Transform), but occasionally subclasses will * provide an optimized implementation which minimizes string copies. */ public incremented Inversion* http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Analysis/CaseFolder.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Analysis/CaseFolder.cfh b/core/Lucy/Analysis/CaseFolder.cfh index cce788b..5c7dcba 100644 --- a/core/Lucy/Analysis/CaseFolder.cfh +++ b/core/Lucy/Analysis/CaseFolder.cfh @@ -18,7 +18,7 @@ parcel Lucy; /** Normalize case, facilitating case-insensitive search. * - * CaseFolder is DEPRECATED. Use L<Normalizer|Lucy::Analysis::Normalizer> + * CaseFolder is DEPRECATED. Use [](cfish:Normalizer) * instead. * * CaseFolder normalizes text according to Unicode case-folding rules, so that http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Analysis/EasyAnalyzer.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Analysis/EasyAnalyzer.cfh b/core/Lucy/Analysis/EasyAnalyzer.cfh index 905f914..3d1ac88 100644 --- a/core/Lucy/Analysis/EasyAnalyzer.cfh +++ b/core/Lucy/Analysis/EasyAnalyzer.cfh @@ -19,9 +19,9 @@ parcel Lucy; /** A simple analyzer chain. * * EasyAnalyzer is an analyzer chain consisting of a - * L<StandardTokenizer|Lucy::Analysis::StandardTokenizer>, a - * L<Normalizer|Lucy::Analysis::Normalizer>, and a - * L<SnowballStemmer|Lucy::Analysis::SnowballStemmer>. + * [](cfish:StandardTokenizer), a + * [](cfish:Normalizer), and a + * [](cfish:SnowballStemmer). * * Supported languages: * http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Analysis/Normalizer.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Analysis/Normalizer.cfh b/core/Lucy/Analysis/Normalizer.cfh index f46ee63..39ec376 100644 --- a/core/Lucy/Analysis/Normalizer.cfh +++ b/core/Lucy/Analysis/Normalizer.cfh @@ -18,7 +18,7 @@ parcel Lucy; /** Unicode normalization, case folding and accent stripping. * - * Normalizer is an L<Analyzer|Lucy::Analysis::Analyzer> which normalizes + * Normalizer is an [](cfish:Analyzer) which normalizes * tokens to one of the Unicode normalization forms. Optionally, it * performs Unicode case folding and converts accented characters to their * base character. http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Analysis/PolyAnalyzer.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Analysis/PolyAnalyzer.cfh b/core/Lucy/Analysis/PolyAnalyzer.cfh index 5108259..437f9fa 100644 --- a/core/Lucy/Analysis/PolyAnalyzer.cfh +++ b/core/Lucy/Analysis/PolyAnalyzer.cfh @@ -18,16 +18,16 @@ parcel Lucy; /** Multiple Analyzers in series. * - * A PolyAnalyzer is a series of L<Analyzers|Lucy::Analysis::Analyzer>, + * A PolyAnalyzer is a series of [Analyzers](cfish:Analyzer), * each of which will be called upon to "analyze" text in turn. You can * either provide the Analyzers yourself, or you can specify a supported * language, in which case a PolyAnalyzer consisting of a - * L<CaseFolder|Lucy::Analysis::CaseFolder>, a - * L<RegexTokenizer|Lucy::Analysis::RegexTokenizer>, and a - * L<SnowballStemmer|Lucy::Analysis::SnowballStemmer> will be generated for you. + * [](cfish:CaseFolder), a + * [](cfish:RegexTokenizer), and a + * [](cfish:SnowballStemmer) will be generated for you. * * The language parameter is DEPRECATED. Use - * L<EasyAnalyzer|Lucy::Analysis::EasyAnalyzer> instead. + * [](cfish:EasyAnalyzer) instead. * * Supported languages: * @@ -56,7 +56,7 @@ public class Lucy::Analysis::PolyAnalyzer inherits Lucy::Analysis::Analyzer { /** * @param language An ISO code from the list of supported languages. - * DEPRECATED, use L<EasyAnalyzer|Lucy::Analysis::EasyAnalyzer> instead. + * DEPRECATED, use [](cfish:EasyAnalyzer) instead. * @param analyzers An array of Analyzers. The order of the analyzers * matters. Don't put a SnowballStemmer before a RegexTokenizer (can't stem whole * documents or paragraphs -- just individual words), or a SnowballStopFilter http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Analysis/SnowballStemmer.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Analysis/SnowballStemmer.cfh b/core/Lucy/Analysis/SnowballStemmer.cfh index 4fe92a0..0777eac 100644 --- a/core/Lucy/Analysis/SnowballStemmer.cfh +++ b/core/Lucy/Analysis/SnowballStemmer.cfh @@ -18,7 +18,7 @@ parcel Lucy; /** Reduce related words to a shared root. * - * SnowballStemmer is an L<Analyzer|Lucy::Analysis::Analyzer> which reduces + * SnowballStemmer is an [](cfish:Analyzer) which reduces * related words to a root form (using the "Snowball" stemming library). For * instance, "horse", "horses", and "horsing" all become "hors" -- so that a * search for 'horse' will also match documents containing 'horses' and http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Analysis/Token.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Analysis/Token.cfh b/core/Lucy/Analysis/Token.cfh index 831f360..0c229dd 100644 --- a/core/Lucy/Analysis/Token.cfh +++ b/core/Lucy/Analysis/Token.cfh @@ -39,7 +39,7 @@ parcel Lucy; * more or less importance to a particular token, as you might for emboldened * text within an HTML document, for example. (Note: The field this token * belongs to must be spec'd to use a posting of type - * L<Lucy::Index::Posting::RichPosting>.) + * [](cfish:RichPosting).) * * `pos_inc` is the POSition INCrement, measured in Tokens. This * attribute, which defaults to 1, is a an advanced tool for manipulating http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Docs/FileLocking.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Docs/FileLocking.cfh b/core/Lucy/Docs/FileLocking.cfh index 0192c71..7e17bd4 100644 --- a/core/Lucy/Docs/FileLocking.cfh +++ b/core/Lucy/Docs/FileLocking.cfh @@ -39,7 +39,7 @@ parcel Lucy; * complex. * * Once an index file is no longer listed in the most recent snapshot, Indexer - * attempts to delete it as part of a post-Commit() cleanup routine. It is + * attempts to delete it as part of a post-[](cfish:Indexer.Commit) cleanup routine. It is * possible that at the moment an Indexer is deleting files which it believes * no longer needed, a Searcher referencing an earlier snapshot is in fact * using them. The more often that an index is either updated or searched, @@ -61,9 +61,9 @@ parcel Lucy; * * Under normal circumstances, it is neither necessary nor desirable for * IndexReaders to secure read locks against an index, but for NFS we have to - * make an exception. LockFactory's Make_Shared_Lock() method exists for this + * make an exception. LockFactory's [](cfish:LockFactory.Make_Shared_Lock) method exists for this * reason; supplying an IndexManager instance to IndexReader's constructor - * activates an internal locking mechanism using Make_Shared_Lock() which + * activates an internal locking mechanism using [](cfish:LockFactory.Make_Shared_Lock) which * prevents concurrent indexing processes from deleting files that are needed * by active readers. * http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Highlight/Highlighter.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Highlight/Highlighter.cfh b/core/Lucy/Highlight/Highlighter.cfh index 72010c0..bfeaae3 100644 --- a/core/Lucy/Highlight/Highlighter.cfh +++ b/core/Lucy/Highlight/Highlighter.cfh @@ -40,12 +40,12 @@ public class Lucy::Highlight::Highlighter inherits Clownfish::Obj { /** * @param searcher An object which inherits from - * L<Searcher|Lucy::Search::Searcher>, such as an - * L<IndexSearcher|Lucy::Search::IndexSearcher>. + * [](cfish:Searcher), such as an + * [](cfish:IndexSearcher). * @param query Query object or a query string. * @param field The name of the field from which to draw the excerpt. The * field must marked as be `highlightable` (see - * L<FieldType|Lucy::Plan::FieldType>). + * [](cfish:FieldType)). * @param excerpt_length Maximum length of the excerpt, in characters. */ public inert Highlighter* @@ -59,7 +59,7 @@ public class Lucy::Highlight::Highlighter inherits Clownfish::Obj { Create_Excerpt(Highlighter *self, HitDoc *hit_doc); /** Encode text with HTML entities. This method is called internally by - * Create_Excerpt() for each text fragment when assembling an excerpt. A + * [](cfish:.Create_Excerpt) for each text fragment when assembling an excerpt. A * subclass can override this if the text should be encoded differently or * not at all. */ @@ -67,7 +67,7 @@ public class Lucy::Highlight::Highlighter inherits Clownfish::Obj { Encode(Highlighter *self, String *text); /** Highlight a small section of text. By default, prepends pre-tag and - * appends post-tag. This method is called internally by Create_Excerpt() + * appends post-tag. This method is called internally by [](cfish:.Create_Excerpt) * when assembling an excerpt. */ public incremented String* http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/BackgroundMerger.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/BackgroundMerger.cfh b/core/Lucy/Index/BackgroundMerger.cfh index 9804de8..6e92b97 100644 --- a/core/Lucy/Index/BackgroundMerger.cfh +++ b/core/Lucy/Index/BackgroundMerger.cfh @@ -23,7 +23,7 @@ parcel Lucy; * complete. See L<Lucy::Docs::Cookbook::FastUpdates> for how to use * this class to control worst-case index update performance. * - * As with L<Indexer|Lucy::Index::Indexer>, see + * As with [](cfish:Indexer), see * L<Lucy::Docs::FileLocking> if your index is on a shared volume. */ public class Lucy::Index::BackgroundMerger nickname BGMerger @@ -68,16 +68,16 @@ public class Lucy::Index::BackgroundMerger nickname BGMerger /** Commit any changes made to the index. Until this is called, none of * the changes made during an indexing session are permanent. * - * Calls Prepare_Commit() implicitly if it has not already been called. + * Calls [](cfish:.Prepare_Commit) implicitly if it has not already been called. */ public void Commit(BackgroundMerger *self); - /** Perform the expensive setup for Commit() in advance, so that Commit() + /** Perform the expensive setup for [](cfish:.Commit) in advance, so that [](cfish:.Commit) * completes quickly. * - * Towards the end of Prepare_Commit(), the BackgroundMerger attempts to - * re-acquire the write lock, which is then held until Commit() finishes + * Towards the end of [](cfish:.Prepare_Commit), the BackgroundMerger attempts to + * re-acquire the write lock, which is then held until [](cfish:.Commit) finishes * and releases it. */ public void http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/DataReader.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/DataReader.cfh b/core/Lucy/Index/DataReader.cfh index f5f9988..e759f4f 100644 --- a/core/Lucy/Index/DataReader.cfh +++ b/core/Lucy/Index/DataReader.cfh @@ -19,7 +19,7 @@ parcel Lucy; /** Abstract base class for reading index data. * * DataReader is the companion class to - * L<DataWriter|Lucy::Index::DataWriter>. Every index component will + * [](cfish:DataWriter). Every index component will * implement one of each. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/DataWriter.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/DataWriter.cfh b/core/Lucy/Index/DataWriter.cfh index efbb716..9f2f694 100644 --- a/core/Lucy/Index/DataWriter.cfh +++ b/core/Lucy/Index/DataWriter.cfh @@ -21,10 +21,10 @@ parcel Lucy; * DataWriter is an abstract base class for writing index data, generally in * segment-sized chunks. Each component of an index -- e.g. stored fields, * lexicon, postings, deletions -- is represented by a - * DataWriter/L<DataReader|Lucy::Index::DataReader> pair. + * DataWriter/[](cfish:DataReader) pair. * * Components may be specified per index by subclassing - * L<Architecture|Lucy::Plan::Architecture>. + * [](cfish:Architecture). */ public class Lucy::Index::DataWriter inherits Clownfish::Obj { @@ -83,7 +83,7 @@ public class Lucy::Index::DataWriter inherits Clownfish::Obj { /** Move content from an existing segment into the one currently being * written. * - * The default implementation calls Add_Segment() then Delete_Segment(). + * The default implementation calls [](cfish:.Add_Segment) then [](cfish:.Delete_Segment). * * @param reader The SegReader containing content to merge, which must * represent a segment which is part of the the current snapshot. http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/DeletionsWriter.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/DeletionsWriter.cfh b/core/Lucy/Index/DeletionsWriter.cfh index 140e374..cfd2200 100644 --- a/core/Lucy/Index/DeletionsWriter.cfh +++ b/core/Lucy/Index/DeletionsWriter.cfh @@ -51,7 +51,7 @@ public abstract class Lucy::Index::DeletionsWriter nickname DelWriter /** Delete all documents in the index that match `query`. * - * @param query A L<Query|Lucy::Search::Query>. + * @param query A [](cfish:Query). */ public abstract void Delete_By_Query(DeletionsWriter *self, Query *query); http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/DocReader.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/DocReader.cfh b/core/Lucy/Index/DocReader.cfh index 182e2e3..57c5f63 100644 --- a/core/Lucy/Index/DocReader.cfh +++ b/core/Lucy/Index/DocReader.cfh @@ -20,7 +20,7 @@ parcel Lucy; * * DocReader defines the interface by which documents (with all stored fields) * are retrieved from the index. The default implementation returns - * L<HitDoc|Lucy::Document::HitDoc> objects. + * [](cfish:HitDoc) objects. */ public class Lucy::Index::DocReader inherits Lucy::Index::DataReader { http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/IndexManager.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/IndexManager.cfh b/core/Lucy/Index/IndexManager.cfh index 03795cd..a4ae10c 100644 --- a/core/Lucy/Index/IndexManager.cfh +++ b/core/Lucy/Index/IndexManager.cfh @@ -21,7 +21,7 @@ parcel Lucy; * IndexManager is an advanced-use class for controlling index locking, * updating, merging, and deletion behaviors. * - * IndexManager and L<Architecture|Lucy::Plan::Architecture> are + * IndexManager and [](cfish:Architecture) 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. http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/IndexReader.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/IndexReader.cfh b/core/Lucy/Index/IndexReader.cfh index 80d7584..c0becb0 100644 --- a/core/Lucy/Index/IndexReader.cfh +++ b/core/Lucy/Index/IndexReader.cfh @@ -19,7 +19,7 @@ parcel Lucy; /** Read from an inverted index. * * IndexReader is the interface through which - * L<IndexSearcher|Lucy::Search::IndexSearcher> objects access the + * [](cfish:IndexSearcher) objects access the * content of an index. * * IndexReader objects always represent a point-in-time view of an index as it @@ -28,10 +28,10 @@ parcel Lucy; * after the update process completes. * * IndexReaders are composites; most of the work is done by individual - * L<DataReader|Lucy::Index::DataReader> sub-components, which may be - * accessed via Fetch() and Obtain(). The most efficient and powerful access + * [](cfish:DataReader) sub-components, which may be + * accessed via [](cfish:.Fetch) and [](cfish:.Obtain). The most efficient and powerful access * to index data happens at the segment level via - * L<SegReader|Lucy::Index::SegReader>'s sub-components. + * [](cfish:SegReader)'s sub-components. */ public class Lucy::Index::IndexReader nickname IxReader @@ -57,7 +57,7 @@ public class Lucy::Index::IndexReader nickname IxReader * @param index Either a string filepath or a Folder. * @param snapshot A Snapshot. If not supplied, the most recent snapshot * file will be used. - * @param manager An L<IndexManager|Lucy::Index::IndexManager>. + * @param manager An [](cfish:IndexManager). * Read-locking is off by default; supplying this argument turns it on. */ public inert nullable IndexReader* http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/Indexer.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/Indexer.cfh b/core/Lucy/Index/Indexer.cfh index 20dccf3..52947d5 100644 --- a/core/Lucy/Index/Indexer.cfh +++ b/core/Lucy/Index/Indexer.cfh @@ -20,18 +20,18 @@ parcel Lucy; * * The Indexer class is Apache Lucy's primary tool for managing the content of * inverted indexes, which may later be searched using - * L<IndexSearcher|Lucy::Search::IndexSearcher>. + * [](cfish:IndexSearcher). * * 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. * * If an index is located on a shared volume, each writer application must * identify itself by supplying an - * L<IndexManager|Lucy::Index::IndexManager> with a unique + * [](cfish:IndexManager) with a unique * `host` id to Indexer's constructor or index corruption will * occur. See L<Lucy::Docs::FileLocking> for a detailed discussion. * - * Note: at present, Delete_By_Term() and Delete_By_Query() only affect + * Note: at present, [](cfish:.Delete_By_Term) and [](cfish:.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. @@ -94,7 +94,7 @@ public class Lucy::Index::Indexer inherits Clownfish::Obj { /** 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. + * [](cfish:.Commit) succeeds. * * @param field The name of an indexed field. (If it is not spec'd as * `indexed`, an error will occur.) @@ -107,7 +107,7 @@ public class Lucy::Index::Indexer inherits Clownfish::Obj { /** Mark documents which match the supplied Query as deleted. * - * @param query A L<Query|Lucy::Search::Query>. + * @param query A [](cfish:Query). */ public void Delete_By_Query(Indexer *self, Query *query); @@ -123,20 +123,20 @@ public class Lucy::Index::Indexer inherits Clownfish::Obj { * while, as it can involve rewriting large amounts of data. * * Every Indexer session which changes index content and ends in a - * Commit() creates a new segment. Once written, segments are never + * [](cfish:.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. * - * 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 + * The [](cfish:.Optimize) method causes all existing index content to be fed back + * into the Indexer. When [](cfish:.Commit) completes after an [](cfish:.Optimize), the + * index will consist of one segment. So [](cfish:.Optimize) must be called + * before [](cfish:.Commit). Also, optimizing a fresh index created from scratch * has no effect. * * 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. + * [](cfish:.Optimize) is rarely justified. */ public void Optimize(Indexer *self); @@ -144,15 +144,15 @@ public class Lucy::Index::Indexer inherits Clownfish::Obj { /** Commit any changes made to the index. Until this is called, none of * the changes made during an indexing session are permanent. * - * Calling Commit() invalidates the Indexer, so if you want to make more + * Calling [](cfish:.Commit) invalidates the Indexer, so if you want to make more * changes you'll need a new one. */ public void Commit(Indexer *self); - /** 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.) + /** Perform the expensive setup for [](cfish:.Commit) in advance, so that [](cfish:.Commit) + * completes quickly. (If [](cfish:.Prepare_Commit) is not called explicitly by + * the user, [](cfish:.Commit) will call it internally.) */ public void Prepare_Commit(Indexer *self); http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/Inverter.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/Inverter.cfh b/core/Lucy/Index/Inverter.cfh index 7858a0a..3463043 100644 --- a/core/Lucy/Index/Inverter.cfh +++ b/core/Lucy/Index/Inverter.cfh @@ -42,13 +42,13 @@ class Lucy::Index::Inverter inherits Clownfish::Obj { inert Inverter* init(Inverter *self, Schema *schema, Segment *segment); - /** Invert the document, first calling Set_Doc(), then Add_Field() for + /** Invert the document, first calling [](cfish:.Set_Doc), then [](cfish:.Add_Field) for * each field in the Doc. */ public void Invert_Doc(Inverter *self, Doc *doc); - /** Set the object's `doc` member. Calls Clear() as side + /** Set the object's `doc` member. Calls [](cfish:.Clear) as side * effect. */ public void @@ -63,7 +63,7 @@ class Lucy::Index::Inverter inherits Clownfish::Obj { * it. * * The InverterEntry's value should have already been set to the field's - * value when Add_Field() is called. + * value when [](cfish:.Add_Field) is called. */ void Add_Field(Inverter *self, InverterEntry *entry); http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/Lexicon.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/Lexicon.cfh b/core/Lucy/Index/Lexicon.cfh index 16058c1..686f931 100644 --- a/core/Lucy/Index/Lexicon.cfh +++ b/core/Lucy/Index/Lexicon.cfh @@ -55,7 +55,7 @@ public class Lucy::Index::Lexicon nickname Lex inherits Clownfish::Obj { public abstract bool Next(Lexicon *self); - /** Reset the iterator. Next() must be called to proceed to the first + /** Reset the iterator. [](cfish:.Next) must be called to proceed to the first * element. */ public abstract void http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/PolyReader.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/PolyReader.cfh b/core/Lucy/Index/PolyReader.cfh index 6624c7a..bae82e1 100644 --- a/core/Lucy/Index/PolyReader.cfh +++ b/core/Lucy/Index/PolyReader.cfh @@ -20,11 +20,11 @@ parcel Lucy; * * 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. + * [](cfish:.Doc_Max) method will return 30. * - * Some of PolyReader's L<DataReader|Lucy::Index::DataReader> components + * Some of PolyReader's [](cfish:DataReader) components * may be less efficient or complete than the single-segment implementations - * accessed via L<SegReader|Lucy::Index::SegReader>. + * accessed via [](cfish:SegReader). */ public class Lucy::Index::PolyReader inherits Lucy::Index::IndexReader { @@ -37,10 +37,10 @@ public class Lucy::Index::PolyReader inherits Lucy::Index::IndexReader { open(Obj *index, Snapshot *snapshot = NULL, IndexManager *manager = NULL); /** - * @param index Either a string filepath or a L<Lucy::Folder>. + * @param index Either a string filepath or a [](cfish:Folder). * @param snapshot A Snapshot. If not supplied, the most recent snapshot * file will be used. - * @param manager An L<IndexManager|Lucy::Index::IndexManager>. + * @param manager An [](cfish:IndexManager). * Read-locking is off by default; supplying this argument turns it on. */ public inert nullable PolyReader* http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/Posting.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/Posting.cfh b/core/Lucy/Index/Posting.cfh index 0adb476..b6fa3d4 100644 --- a/core/Lucy/Index/Posting.cfh +++ b/core/Lucy/Index/Posting.cfh @@ -23,9 +23,9 @@ parcel Lucy; * academic definition of "posting".) * * Subclasses include - * L<MatchPosting|Lucy::Index::Posting::MatchPosting>, the simplest + * [](cfish:MatchPosting), the simplest * posting format, and - * L<ScorePosting|Lucy::Index::Posting::ScorePosting>, the default. + * [](cfish:ScorePosting), the default. */ class Lucy::Index::Posting nickname Post inherits Lucy::Util::Stepper { http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/Posting/RichPosting.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/Posting/RichPosting.cfh b/core/Lucy/Index/Posting/RichPosting.cfh index df75449..d2cde9f 100644 --- a/core/Lucy/Index/Posting/RichPosting.cfh +++ b/core/Lucy/Index/Posting/RichPosting.cfh @@ -19,10 +19,10 @@ parcel Lucy; /** Posting with per-position boost. * * RichPosting is similar to - * L<ScorePosting|Lucy::Index::Posting::ScorePosting>, but weighting is + * [](cfish:ScorePosting), but weighting is * per-position rather than per-field. To exploit this, you need a custom - * L<Analyzer|Lucy::Analysis::Analyzer> which assigns varying boosts to - * individual L<Token|Lucy::Analysis::Token> objects. + * [](cfish:Analyzer) which assigns varying boosts to + * individual [](cfish:Token) objects. * * A typical application for RichPosting is an HTMLAnalyzer which assigns * boost based on the visual size and weight of the marked up text: H1 http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/PostingList.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/PostingList.cfh b/core/Lucy/Index/PostingList.cfh index 702db7c..f3e4b0a 100644 --- a/core/Lucy/Index/PostingList.cfh +++ b/core/Lucy/Index/PostingList.cfh @@ -54,7 +54,7 @@ public class Lucy::Index::PostingList nickname PList abstract void Seek_Lex(PostingList *self, Lexicon *lexicon); - /** Invoke Post_Make_Matcher() for this PostingList's posting. + /** Invoke [](cfish:.Post_Make_Matcher) for this PostingList's posting. */ abstract Matcher* Make_Matcher(PostingList *self, Similarity *similarity, http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/PostingListReader.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/PostingListReader.cfh b/core/Lucy/Index/PostingListReader.cfh index a961fc9..b09c372 100644 --- a/core/Lucy/Index/PostingListReader.cfh +++ b/core/Lucy/Index/PostingListReader.cfh @@ -18,7 +18,7 @@ parcel Lucy; /** Read postings data. * - * PostingListReaders produce L<PostingList|Lucy::Index::PostingList> + * PostingListReaders produce [](cfish:PostingList) * objects which convey document matching information. */ public class Lucy::Index::PostingListReader nickname PListReader @@ -34,7 +34,7 @@ public class Lucy::Index::PostingListReader nickname PListReader * * @param field A field name. * @param term If supplied, the PostingList will be pre-located to this - * term using Seek(). + * term using [](cfish:PostingList.Seek). */ public abstract incremented nullable PostingList* Posting_List(PostingListReader *self, String *field = NULL, http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/SegPostingList.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/SegPostingList.cfh b/core/Lucy/Index/SegPostingList.cfh index bf2cc3f..4683bfe 100644 --- a/core/Lucy/Index/SegPostingList.cfh +++ b/core/Lucy/Index/SegPostingList.cfh @@ -69,7 +69,7 @@ class Lucy::Index::SegPostingList nickname SegPList public void Seek(SegPostingList *self, Obj *target = NULL); - /** Optimized version of Seek(), designed to speed sequential access. + /** Optimized version of [](cfish:.Seek), designed to speed sequential access. */ void Seek_Lex(SegPostingList *self, Lexicon *lexicon); http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/SegReader.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/SegReader.cfh b/core/Lucy/Index/SegReader.cfh index e34977e..5ae6af7 100644 --- a/core/Lucy/Index/SegReader.cfh +++ b/core/Lucy/Index/SegReader.cfh @@ -24,7 +24,7 @@ parcel Lucy; * data at the segment level need to deal with the SegReader API directly. * * Nearly all of SegReader's functionality is implemented by pluggable - * components spawned by L<Architecture|Lucy::Plan::Architecture>'s + * components spawned by [](cfish:Architecture)'s * factory methods. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/SegWriter.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/SegWriter.cfh b/core/Lucy/Index/SegWriter.cfh index a7bad7e..17b2d7d 100644 --- a/core/Lucy/Index/SegWriter.cfh +++ b/core/Lucy/Index/SegWriter.cfh @@ -20,16 +20,16 @@ parcel Lucy; /** Write one segment of an index. * * SegWriter is a conduit through which information fed to Indexer passes. It - * manages L<Segment|Lucy::Index::Segment> and Inverter, invokes the - * L<Analyzer|Lucy::Analysis::Analyzer> chain, and feeds low - * level L<DataWriters|Lucy::Index::DataWriter> such as + * manages [](cfish:Segment) and Inverter, invokes the + * [](cfish:Analyzer) chain, and feeds low + * level [DataWriters](cfish:DataWriter) such as * PostingListWriter and DocWriter. * * The sub-components of a SegWriter are determined by - * L<Architecture|Lucy::Plan::Architecture>. 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(). + * [](cfish:Architecture). DataWriter components + * which are added to the stack of writers via [](cfish:.Add_Writer) have + * [](cfish:.Add_Inverted_Doc) invoked for each document supplied to SegWriter's + * [](cfish:.Add_Doc). */ public class Lucy::Index::SegWriter inherits Lucy::Index::DataWriter { @@ -57,8 +57,8 @@ public class Lucy::Index::SegWriter inherits Lucy::Index::DataWriter { /** * 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()). + * registration simply makes the writer available via [](cfish:.Fetch), so you may + * also want to call [](cfish:.Add_Writer)). * * @param api The name of the DataWriter api which `writer` * implements. @@ -89,7 +89,7 @@ public class Lucy::Index::SegWriter inherits Lucy::Index::DataWriter { Prep_Seg_Dir(SegWriter *self); /** Add a document to the segment. Inverts `doc`, increments - * the Segment's internal document id, then calls Add_Inverted_Doc(), + * the Segment's internal document id, then calls [](cfish:.Add_Inverted_Doc), * feeding all sub-writers. */ public void http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Index/Snapshot.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/Snapshot.cfh b/core/Lucy/Index/Snapshot.cfh index c7d69b7..1e18cda 100644 --- a/core/Lucy/Index/Snapshot.cfh +++ b/core/Lucy/Index/Snapshot.cfh @@ -22,7 +22,7 @@ parcel Lucy; * written, are never modified, a Snapshot defines a point-in-time view of the * data in an index. * - * L<IndexReader|Lucy::Index::IndexReader> objects interpret the data + * [](cfish:IndexReader) objects interpret the data * associated with a single Snapshot. */ @@ -95,7 +95,7 @@ public class Lucy::Index::Snapshot inherits Clownfish::Obj { Set_Path(Snapshot *self, String *path); /** Get the path to the snapshot file. Initially NULL; updated by - * Read_File(), Write_File(), and Set_Path(). + * [](cfish:.Read_File), [](cfish:.Write_File), and [](cfish:.Set_Path). */ public nullable String* Get_Path(Snapshot *self); http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Plan/Architecture.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Plan/Architecture.cfh b/core/Lucy/Plan/Architecture.cfh index d35f5bf..bfd12ae 100644 --- a/core/Lucy/Plan/Architecture.cfh +++ b/core/Lucy/Plan/Architecture.cfh @@ -22,8 +22,8 @@ parcel Lucy; * 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 - * L<SegWriter|Lucy::Index::SegWriter> and - * L<SegReader|Lucy::Index::SegReader>. + * [](cfish:SegWriter) and + * [](cfish:SegReader). */ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj { @@ -42,7 +42,7 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj { public void Init_Seg_Writer(Architecture *self, SegWriter *writer); - /** Spawn a LexiconWriter and Register() it with the supplied SegWriter, + /** Spawn a LexiconWriter and [](cfish:SegWriter.Register) it with the supplied SegWriter, * but don't add it to the SegWriter's writer stack. * * @param writer A SegWriter. @@ -50,7 +50,7 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj { public void Register_Lexicon_Writer(Architecture *self, SegWriter *writer); - /** Spawn a PostingListWriter and Register() it with the supplied + /** Spawn a PostingListWriter and [](cfish:SegWriter.Register) it with the supplied * SegWriter, adding it to the SegWriter's writer stack. The SegWriter * must contain a previously registered LexiconWriter. * @@ -59,7 +59,7 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj { public void Register_Posting_List_Writer(Architecture *self, SegWriter *writer); - /** Spawn a DataWriter and Register() it with the supplied SegWriter, + /** Spawn a DataWriter and [](cfish:SegWriter.Register) it with the supplied SegWriter, * adding it to the SegWriter's writer stack. * * @param writer A SegWriter. @@ -67,7 +67,7 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj { public void Register_Doc_Writer(Architecture *self, SegWriter *writer); - /** Spawn a SortWriter and Register() it with the supplied SegWriter, + /** Spawn a SortWriter and [](cfish:SegWriter.Register) it with the supplied SegWriter, * adding it to the SegWriter's writer stack. * * @param writer A SegWriter. @@ -75,7 +75,7 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj { public void Register_Sort_Writer(Architecture *self, SegWriter *writer); - /** Spawn a HighlightWriter and Register() it with the supplied SegWriter, + /** Spawn a HighlightWriter and [](cfish:SegWriter.Register) it with the supplied SegWriter, * adding it to the SegWriter's writer stack. * * @param writer A SegWriter. @@ -83,8 +83,8 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj { public void Register_Highlight_Writer(Architecture *self, SegWriter *writer); - /** Spawn a DeletionsWriter and Register() it with the supplied SegWriter, - * also calling Set_Del_Writer(). + /** Spawn a DeletionsWriter and [](cfish:SegWriter.Register) it with the supplied SegWriter, + * also calling [](cfish:SegWriter.Set_Del_Writer). * * @param writer A SegWriter. */ @@ -96,28 +96,28 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj { public void Init_Seg_Reader(Architecture *self, SegReader *reader); - /** Spawn a DocReader and Register() it with the supplied SegReader. + /** Spawn a DocReader and [](cfish:SegReader.Register) it with the supplied SegReader. * * @param reader A SegReader. */ public void Register_Doc_Reader(Architecture *self, SegReader *reader); - /** Spawn a PostingListReader and Register() it with the supplied SegReader. + /** Spawn a PostingListReader and [](cfish:SegReader.Register) it with the supplied SegReader. * * @param reader A SegReader. */ public void Register_Posting_List_Reader(Architecture *self, SegReader *reader); - /** Spawn a SortReader and Register() it with the supplied SegReader. + /** Spawn a SortReader and [](cfish:SegReader.Register) it with the supplied SegReader. * * @param reader A SegReader. */ public void Register_Sort_Reader(Architecture *self, SegReader *reader); - /** Spawn a HighlightReader and Register() it with the supplied + /** Spawn a HighlightReader and [](cfish:SegReader.Register) it with the supplied * SegReader. * * @param reader A SegReader. @@ -125,14 +125,14 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj { public void Register_Highlight_Reader(Architecture *self, SegReader *reader); - /** Spawn a LexiconReader and Register() it with the supplied SegReader. + /** Spawn a LexiconReader and [](cfish:SegReader.Register) it with the supplied SegReader. * * @param reader A SegReader. */ public void Register_Lexicon_Reader(Architecture *self, SegReader *reader); - /** Spawn a DeletionsReader and Register() it with the supplied SegReader. + /** Spawn a DeletionsReader and [](cfish:SegReader.Register) it with the supplied SegReader. * * @param reader A SegReader. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Plan/FieldType.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Plan/FieldType.cfh b/core/Lucy/Plan/FieldType.cfh index 3124493..f20d858 100644 --- a/core/Lucy/Plan/FieldType.cfh +++ b/core/Lucy/Plan/FieldType.cfh @@ -65,7 +65,7 @@ __END_C__ * not settable. * * The `similarity` property is a - * L<Similarity|Lucy::Index::Similarity> object which defines matching + * [](cfish:Similarity) object which defines matching * and scoring behavior for the field. It is required if the field is * `indexed`. */ @@ -130,7 +130,7 @@ public abstract class Lucy::Plan::FieldType nickname FType Binary(FieldType *self); /** Compare two values for the field. The default implementation - * dispatches to the Compare_To() method of argument `a`. + * dispatches to the [](cfish:.Compare_To) method of argument `a`. * * @return a negative number if a is "less than" b, 0 if they are "equal", * and a positive number if a is "greater than" b. http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Plan/FullTextType.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Plan/FullTextType.cfh b/core/Lucy/Plan/FullTextType.cfh index d94c69d..a98a1e7 100644 --- a/core/Lucy/Plan/FullTextType.cfh +++ b/core/Lucy/Plan/FullTextType.cfh @@ -19,14 +19,14 @@ parcel Lucy; /** Full-text search field type. * * Lucy::Plan::FullTextType is an implementation of - * L<Lucy::Plan::FieldType> tuned for "full text search". + * [](cfish:FieldType) tuned for "full text search". * * Full text fields are associated with an - * L<Analyzer|Lucy::Analysis::Analyzer>, which is used to tokenize and + * [](cfish:Analyzer), which is used to tokenize and * normalize the text so that it can be searched for individual words. * * For an exact-match, single value field type using character data, see - * L<StringType|Lucy::Plan::StringType>. + * [](cfish:StringType). */ public class Lucy::Plan::FullTextType inherits Lucy::Plan::TextType { @@ -54,7 +54,7 @@ public class Lucy::Plan::FullTextType inherits Lucy::Plan::TextType { new(Analyzer *analyzer); /** Indicate whether to store data required by - * L<Lucy::Highlight::Highlighter> for excerpt selection and search + * [](cfish:Highlighter) for excerpt selection and search * term highlighting. */ public void http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Plan/Schema.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Plan/Schema.cfh b/core/Lucy/Plan/Schema.cfh index 6d00eac..3f3f415 100644 --- a/core/Lucy/Plan/Schema.cfh +++ b/core/Lucy/Plan/Schema.cfh @@ -51,7 +51,7 @@ public class Lucy::Plan::Schema inherits Clownfish::Obj { * * If this method has already been called for the supplied * `field`, it will merely test to verify that the supplied - * FieldType Equals() the existing one. + * FieldType [](cfish:.Equals) the existing one. * * @param name The name of the field. * @param type A FieldType. http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/ANDQuery.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/ANDQuery.cfh b/core/Lucy/Search/ANDQuery.cfh index 0c2e94a..e838338 100644 --- a/core/Lucy/Search/ANDQuery.cfh +++ b/core/Lucy/Search/ANDQuery.cfh @@ -18,7 +18,7 @@ parcel Lucy; /** Intersect multiple result sets. * - * ANDQuery is a composite L<Query|Lucy::Search::Query> which matches + * ANDQuery is a composite [](cfish:Query) 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. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/Collector.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/Collector.cfh b/core/Lucy/Search/Collector.cfh index 0dd8cc3..d464cc9 100644 --- a/core/Lucy/Search/Collector.cfh +++ b/core/Lucy/Search/Collector.cfh @@ -19,12 +19,12 @@ parcel Lucy; /** Process hits. * * A Collector decides what to do with the hits that a - * L<Matcher|Lucy::Search::Matcher> iterates through, based on how the - * abstract Collect() method is implemented. + * [](cfish:Matcher) iterates through, based on how the + * abstract [](cfish:.Collect) method is implemented. * * 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 + * segment, [](cfish:.Set_Reader), [](cfish:.Set_Base) and [](cfish:.Set_Matcher) will be called, and the * collector must take the updated information into account. */ @@ -57,13 +57,13 @@ public abstract class Lucy::Search::Collector nickname Coll Set_Reader(Collector *self, SegReader *reader); /** Set the "base" document id, an offset which must be added to the - * `doc_id` supplied via Collect() to get the doc id for the + * `doc_id` supplied via [](cfish:.Collect) to get the doc id for the * larger index. */ public void Set_Base(Collector *self, int32_t base); - /** Indicate whether the Collector will call Score() on its Matcher. + /** Indicate whether the Collector will call [](cfish:Matcher.Score) on its Matcher. */ public abstract bool Need_Score(Collector *self); @@ -77,7 +77,7 @@ public abstract class Lucy::Search::Collector nickname Coll /** Collector which records doc nums in a BitVector. * * BitCollector is a Collector which saves matching document ids in a - * L<BitVector|Lucy::Object::BitVector>. It is useful for recording the + * [](cfish:BitVector). It is useful for recording the * entire set of documents which matches a query. */ public class Lucy::Search::Collector::BitCollector nickname BitColl http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/Collector/SortCollector.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/Collector/SortCollector.cfh b/core/Lucy/Search/Collector/SortCollector.cfh index 2df7bb4..331a548 100644 --- a/core/Lucy/Search/Collector/SortCollector.cfh +++ b/core/Lucy/Search/Collector/SortCollector.cfh @@ -66,7 +66,7 @@ class Lucy::Search::Collector::SortCollector nickname SortColl Pop_Match_Docs(SortCollector *self); /** Accessor for "total_hits" member, which tracks the number of times - * that Collect() was called. + * that [](cfish:.Collect) was called. */ uint32_t Get_Total_Hits(SortCollector *self); http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/Compiler.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/Compiler.cfh b/core/Lucy/Search/Compiler.cfh index 4f490cf..1a79b2c 100644 --- a/core/Lucy/Search/Compiler.cfh +++ b/core/Lucy/Search/Compiler.cfh @@ -19,24 +19,24 @@ parcel Lucy; /** Query-to-Matcher compiler. * * The purpose of the Compiler class is to take a specification in the form of - * a L<Query|Lucy::Search::Query> object and compile a - * L<Matcher|Lucy::Search::Matcher> object that can do real work. + * a [](cfish:Query) object and compile a + * [](cfish:Matcher) object that can do real work. * * The simplest Compiler subclasses -- such as those associated with - * constant-scoring Query types -- might simply implement a Make_Matcher() + * constant-scoring Query types -- might simply implement a [](cfish:.Make_Matcher) * method which passes along information verbatim from the Query to the * Matcher's constructor. * * 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(). + * subclass may wish to override [](cfish:.Get_Weight), [](cfish:.Sum_Of_Squared_Weights), and + * [](cfish:.Apply_Norm_Factor). * * Compiling a Matcher is a two stage process. * * The first stage takes place during the Compiler's construction, which is - * where the Query object meets a L<Searcher|Lucy::Search::Searcher> + * where the Query object meets a [](cfish:Searcher) * 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 @@ -45,8 +45,8 @@ parcel Lucy; * TF/IDF weighting algorithm to adjust the Compiler's weight; custom * subclasses might do something similar. * - * The second stage of compilation is Make_Matcher(), method, which is where - * the Compiler meets a L<SegReader|Lucy::Index::SegReader> object. + * The second stage of compilation is [](cfish:.Make_Matcher), method, which is where + * the Compiler meets a [](cfish:SegReader) 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 @@ -54,7 +54,7 @@ parcel Lucy; * 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 + * the Matchers's constructor, or whether [](cfish:.Make_Matcher) should return a * Matcher at all. */ public class Lucy::Search::Compiler inherits Lucy::Search::Query { @@ -78,7 +78,7 @@ public class Lucy::Search::Compiler inherits Lucy::Search::Query { /** Factory method returning a Matcher. * * @param reader A SegReader. - * @param need_score Indicate whether the Matcher must implement Score(). + * @param need_score Indicate whether the Matcher must implement [](cfish:Matcher.Score). * @return a Matcher, or NULL if the Matcher would have matched no * documents. */ @@ -102,7 +102,7 @@ public class Lucy::Search::Compiler inherits Lucy::Search::Query { Get_Parent(Compiler *self); /** Compute and return a raw weighting factor. (This quantity is used by - * Normalize()). By default, simply returns 1.0. + * [](cfish:.Normalize)). By default, simply returns 1.0. */ public float Sum_Of_Squared_Weights(Compiler *self); @@ -122,13 +122,13 @@ public class Lucy::Search::Compiler inherits Lucy::Search::Query { /** 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. + * [](cfish:.Make_Compiler) for top-level nodes. * * For a TermQuery, the scoring formula is approximately: * * (tf_d * idf_t / norm_d) * (tf_q * idf_t / norm_q) * - * Normalize() is theoretically concerned with applying the second half of + * [](cfish:.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. http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/IndexSearcher.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/IndexSearcher.cfh b/core/Lucy/Search/IndexSearcher.cfh index 2495c45..ffd7044 100644 --- a/core/Lucy/Search/IndexSearcher.cfh +++ b/core/Lucy/Search/IndexSearcher.cfh @@ -20,10 +20,10 @@ parcel Lucy; * * Use the IndexSearcher class to perform search queries against an index. * (For searching multiple indexes at once, see - * L<PolySearcher|Lucy::Search::PolySearcher>). + * [](cfish:PolySearcher)). * * IndexSearchers operate against a single point-in-time view or - * L<Snapshot|Lucy::Index::Snapshot> of the index. If an index is + * [](cfish:Snapshot) of the index. If an index is * modified, a new IndexSearcher must be opened to access the changes. */ public class Lucy::Search::IndexSearcher nickname IxSearcher http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/LeafQuery.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/LeafQuery.cfh b/core/Lucy/Search/LeafQuery.cfh index b4d07f1..e195e7f 100644 --- a/core/Lucy/Search/LeafQuery.cfh +++ b/core/Lucy/Search/LeafQuery.cfh @@ -19,10 +19,10 @@ parcel Lucy; /** Leaf node in a tree created by QueryParser. * * LeafQuery objects serve as leaf nodes in the tree structure generated by - * L<QueryParser|Lucy::Search::QueryParser>'s Tree() method. + * [](cfish:QueryParser)'s [](cfish:QueryParser.Tree) method. * Ultimately, they must be transformed, typically into either - * L<TermQuery|Lucy::Search::TermQuery> or - * L<PhraseQuery|Lucy::Search::PhraseQuery> objects, as attempting to + * [](cfish:TermQuery) or + * [](cfish:PhraseQuery) objects, as attempting to * search a LeafQuery causes an error. */ public class Lucy::Search::LeafQuery inherits Lucy::Search::Query { http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/Matcher.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/Matcher.cfh b/core/Lucy/Search/Matcher.cfh index 3d242b5..ed27061 100644 --- a/core/Lucy/Search/Matcher.cfh +++ b/core/Lucy/Search/Matcher.cfh @@ -19,7 +19,7 @@ parcel Lucy; /** Match a set of document ids. * * A Matcher iterates over a set of ascending document ids. Some Matchers - * implement Score() and can assign relevance scores to the docs that they + * implement [](cfish:.Score) and can assign relevance scores to the docs that they * match. Other implementations may be match-only. */ @@ -38,7 +38,7 @@ public abstract class Lucy::Search::Matcher inherits Clownfish::Obj { Next(Matcher *self); /** Advance the iterator to the first doc id greater than or equal to - * `target`. The default implementation simply calls Next() + * `target`. The default implementation simply calls [](cfish:.Next) * over and over, but subclasses have the option of doing something more * efficient. * @@ -50,14 +50,14 @@ public abstract class Lucy::Search::Matcher inherits Clownfish::Obj { Advance(Matcher *self, int32_t target); /** Return the current doc id. Valid only after a successful call to - * Next() or Advance() and must not be called otherwise. + * [](cfish:.Next) or [](cfish:.Advance) and must not be called otherwise. */ public abstract int32_t Get_Doc_ID(Matcher *self); /** Return the score of the current document. * - * Only Matchers which are used for scored search need implement Score(). + * Only Matchers which are used for scored search need implement [](cfish:.Score). */ public abstract float Score(Matcher *self); http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/NOTQuery.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/NOTQuery.cfh b/core/Lucy/Search/NOTQuery.cfh index a9f10ad..39a0aea 100644 --- a/core/Lucy/Search/NOTQuery.cfh +++ b/core/Lucy/Search/NOTQuery.cfh @@ -18,12 +18,12 @@ parcel Lucy; /** Invert the result set of another Query. * - * A NOTQuery wraps another L<Query|Lucy::Search::Query> and matches + * A NOTQuery wraps another [](cfish:Query) and matches * against its inverse document set. All matching docs recieve a score of * 0.0. * * NOTQuery is often used in conjunction with - * L<ANDQuery|Lucy::Search::ANDQuery> to provide "a AND NOT b" + * [](cfish:ANDQuery) to provide "a AND NOT b" * semantics. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/NoMatchQuery.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/NoMatchQuery.cfh b/core/Lucy/Search/NoMatchQuery.cfh index 13a5bc5..52c1055 100644 --- a/core/Lucy/Search/NoMatchQuery.cfh +++ b/core/Lucy/Search/NoMatchQuery.cfh @@ -20,7 +20,7 @@ parcel Lucy; * * NoMatchQuery is a utility class representing a query which matches nothing. * Typical usage might include e.g. returning a NoMatchQuery when a - * L<QueryParser|Lucy::Search::QueryParser> is asked to parse an empty + * [](cfish:QueryParser) is asked to parse an empty * string. */ public class Lucy::Search::NoMatchQuery inherits Lucy::Search::Query { http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/ORMatcher.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/ORMatcher.cfh b/core/Lucy/Search/ORMatcher.cfh index 51bb8d8..39b93fd 100644 --- a/core/Lucy/Search/ORMatcher.cfh +++ b/core/Lucy/Search/ORMatcher.cfh @@ -19,7 +19,7 @@ parcel Lucy; __C__ #include "Lucy/Search/Matcher.h" -/* A wrapper for a Matcher which caches the result of Matcher_Get_Doc_ID(). +/* A wrapper for a Matcher which caches the result of [](cfish:.Matcher_Get_Doc_ID). */ typedef struct lucy_HeapedMatcherDoc { lucy_Matcher *matcher; http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/ORQuery.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/ORQuery.cfh b/core/Lucy/Search/ORQuery.cfh index 8fc5eb8..9f0fca1 100644 --- a/core/Lucy/Search/ORQuery.cfh +++ b/core/Lucy/Search/ORQuery.cfh @@ -18,7 +18,7 @@ parcel Lucy; /** Union multiple result sets. * - * ORQuery is a composite L<Query|Lucy::Search::Query> which matches + * ORQuery is a composite [](cfish:Query) 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. http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/PhraseQuery.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/PhraseQuery.cfh b/core/Lucy/Search/PhraseQuery.cfh index 0f78399..b19f9a0 100644 --- a/core/Lucy/Search/PhraseQuery.cfh +++ b/core/Lucy/Search/PhraseQuery.cfh @@ -18,7 +18,7 @@ parcel Lucy; /** Query matching an ordered list of terms. * - * PhraseQuery is a subclass of L<Lucy::Search::Query> for matching + * PhraseQuery is a subclass of [](cfish:Query) for matching * against an ordered sequence of terms. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/PolyQuery.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/PolyQuery.cfh b/core/Lucy/Search/PolyQuery.cfh index 25c465b..3b8f7f1 100644 --- a/core/Lucy/Search/PolyQuery.cfh +++ b/core/Lucy/Search/PolyQuery.cfh @@ -19,10 +19,10 @@ parcel Lucy; /** Base class for composite Query objects. * * PolyQuery serves as a shared base class for - * L<ANDQuery|Lucy::Search::ANDQuery>, - * L<ORQuery|Lucy::Search::ORQuery>, - * L<NOTQuery|Lucy::Search::NOTQuery>, and - * L<RequiredOptionalQuery|Lucy::Search::RequiredOptionalQuery>. All of + * [](cfish:ANDQuery), + * [](cfish:ORQuery), + * [](cfish:NOTQuery), and + * [](cfish:RequiredOptionalQuery). All of * these classes may serve as nodes in composite Query with a tree structure * which may be walked. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/Query.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/Query.cfh b/core/Lucy/Search/Query.cfh index 2774ee6..116fb82 100644 --- a/core/Lucy/Search/Query.cfh +++ b/core/Lucy/Search/Query.cfh @@ -22,15 +22,15 @@ parcel Lucy; * necessary to define a search query. * * The most common way to generate Query objects is to feed a search string - * such as 'foo AND bar' to a L<QueryParser's|Lucy::Search::QueryParser> - * Parse() method, which outputs an abstract syntax tree built up from various - * Query subclasses such as L<ANDQuery|Lucy::Search::ANDQuery> and - * L<TermQuery|Lucy::Search::TermQuery>. However, it is also possible + * such as 'foo AND bar' to a [QueryParser's](cfish:QueryParser) + * [](cfish:QueryParser.Parse) method, which outputs an abstract syntax tree built up from various + * Query subclasses such as [](cfish:ANDQuery) and + * [](cfish:TermQuery). However, it is also possible * to use custom Query objects to build a search specification which cannot be * easily represented using a search string. * - * Subclasses of Query must implement Make_Compiler(), which is the first step - * in compiling a Query down to a L<Matcher|Lucy::Search::Matcher> which + * Subclasses of Query must implement [](cfish:.Make_Compiler), which is the first step + * in compiling a Query down to a [](cfish:Matcher) which * can actually match and score documents. */ @@ -54,7 +54,7 @@ public class Lucy::Search::Query inherits Clownfish::Obj { * @param boost A scoring multiplier. * @param subordinate Indicates whether the Query is a subquery (as * opposed to a top-level query). If false, the implementation must - * invoke Normalize() on the newly minted Compiler object before returning + * invoke [](cfish:Compiler.Normalize) on the newly minted Compiler object before returning * it. */ public abstract incremented Compiler* http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/QueryParser.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/QueryParser.cfh b/core/Lucy/Search/QueryParser.cfh index d8ef52f..967e7db 100644 --- a/core/Lucy/Search/QueryParser.cfh +++ b/core/Lucy/Search/QueryParser.cfh @@ -19,9 +19,9 @@ parcel Lucy; /** Transform a string into a Query object. * * QueryParser accepts search strings as input and produces - * L<Lucy::Search::Query> objects, suitable for feeding into - * L<IndexSearcher|Lucy::Search::IndexSearcher> and other - * L<Searcher|Lucy::Search::Searcher> subclasses. + * [](cfish:Query) objects, suitable for feeding into + * [](cfish:IndexSearcher) and other + * [](cfish:Searcher) subclasses. * * The following syntactical constructs are recognized by QueryParser: * @@ -32,7 +32,7 @@ parcel Lucy; * * Logical groups, delimited by parentheses. * * Phrases, delimited by double quotes. * - * Additionally, the following syntax can be enabled via Set_Heed_Colons(): + * Additionally, the following syntax can be enabled via [](cfish:.Set_Heed_Colons): * * * Field-specific constructs, in the form of 'fieldname:termtext' or * 'fieldname:(foo bar)'. (The field specified by 'fieldname:' will be @@ -57,8 +57,8 @@ public class Lucy::Search::QueryParser nickname QParser /** Constructor. * - * @param schema A L<Schema|Lucy::Plan::Schema>. - * @param analyzer An L<Analyzer|Lucy::Analysis::Analyzer>. + * @param schema A [](cfish:Schema). + * @param analyzer An [](cfish:Analyzer). * Ordinarily, the analyzers specified by each field's definition will be * used, but if `analyzer` is supplied, it will override and be used for * all fields. This can lead to mismatches between what is in the index @@ -76,7 +76,7 @@ public class Lucy::Search::QueryParser nickname QParser String *default_boolop = NULL, VArray *fields = NULL); /** Build a Query object from the contents of a query string. At present, - * implemented internally by calling Tree(), Expand(), and Prune(). + * implemented internally by calling [](cfish:.Tree), [](cfish:.Expand), and [](cfish:.Prune). * * @param query_string The string to be parsed. May be NULL. * @return a Query. @@ -90,8 +90,8 @@ public class Lucy::Search::QueryParser nickname QParser * well. Internal nodes will be objects which subclass PolyQuery: * ANDQuery, ORQuery, NOTQuery, and RequiredOptionalQuery. * - * The output of Tree() is an intermediate form which must be passed - * through Expand() before being used to feed a search. + * The output of [](cfish:.Tree) is an intermediate form which must be passed + * through [](cfish:.Expand) before being used to feed a search. * * @param query_string The string to be parsed. * @return a Query. @@ -100,7 +100,7 @@ public class Lucy::Search::QueryParser nickname QParser Tree(QueryParser *self, String *query_string); /** Walk the hierarchy of a Query tree, descending through all PolyQuery - * nodes and calling Expand_Leaf() on any LeafQuery nodes encountered. + * nodes and calling [](cfish:.Expand_Leaf) on any LeafQuery nodes encountered. * * @param query A Query object. * @return A Query -- usually the same one that was supplied after @@ -124,23 +124,23 @@ public class Lucy::Search::QueryParser nickname QParser Expand_Leaf(QueryParser *self, Query *query); /** Prevent certain Query structures from returning too many results. - * Query objects built via Tree() and Expand() can generate "return the + * Query objects built via [](cfish:.Tree) and [](cfish:.Expand) can generate "return the * world" result sets, such as in the case of - * `NOT a_term_not_in_the_index`; Prune() walks the hierarchy + * `NOT a_term_not_in_the_index`; [](cfish:.Prune) walks the hierarchy * and eliminates such branches. * * 'NOT foo' => [NOMATCH] * 'foo OR NOT bar' => 'foo' * 'foo OR (-bar AND -baz) => 'foo' * - * Prune() also eliminates some double-negative constructs -- even though + * [](cfish:.Prune) also eliminates some double-negative constructs -- even though * such constructs may not actually return the world: * * 'foo AND -(-bar)' => 'foo' * * In this example, safety is taking precedence over logical consistency. - * If you want logical consistency instead, call Tree() then Expand(), - * skipping Prune(). + * If you want logical consistency instead, call [](cfish:.Tree) then [](cfish:.Expand), + * skipping [](cfish:.Prune). * * * @param query A Query. http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/Searcher.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/Searcher.cfh b/core/Lucy/Search/Searcher.cfh index c61ade3..67263d7 100644 --- a/core/Lucy/Search/Searcher.cfh +++ b/core/Lucy/Search/Searcher.cfh @@ -19,8 +19,8 @@ parcel Lucy; /** Base class for searching collections of documents. * * Abstract base class for objects which search. Core subclasses include - * L<Lucy::Search::IndexSearcher> and - * L<Lucy::Search::PolySearcher>. + * [](cfish:IndexSearcher) and + * [](cfish:PolySearcher). */ public class Lucy::Search::Searcher inherits Clownfish::Obj { @@ -71,7 +71,7 @@ public class Lucy::Search::Searcher inherits Clownfish::Obj { * hits 21-30, assuming that 30 hits can be found. * @param num_wanted The number of hits you would like to see after * `offset` is taken into account. - * @param sort_spec A L<Lucy::Search::SortSpec>, which will affect + * @param sort_spec A [](cfish:SortSpec), which will affect * how results are ranked and returned. */ public incremented Hits* @@ -79,7 +79,7 @@ public class Lucy::Search::Searcher inherits Clownfish::Obj { uint32_t num_wanted = 10, SortSpec *sort_spec = NULL); /** Iterate over hits, feeding them into a - * L<Collector|Lucy::Search::Collector>. + * [](cfish:Collector). * * @param query A Query. * @param collector A Collector. http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/SortRule.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/SortRule.cfh b/core/Lucy/Search/SortRule.cfh index 7a009c2..9eb3715 100644 --- a/core/Lucy/Search/SortRule.cfh +++ b/core/Lucy/Search/SortRule.cfh @@ -19,7 +19,7 @@ parcel Lucy; /** Element of a SortSpec. * * SortRules are the building blocks used to assemble - * L<SortSpecs|Lucy::Search::SortSpec>; each SortRule defines a single + * [SortSpecs](cfish:SortSpec); each SortRule defines a single * level of sorting. For example, sorting first by "category" then by score * requires a SortSpec with two SortRule elements. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/SortSpec.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/SortSpec.cfh b/core/Lucy/Search/SortSpec.cfh index 0c59909..473aa01 100644 --- a/core/Lucy/Search/SortSpec.cfh +++ b/core/Lucy/Search/SortSpec.cfh @@ -20,7 +20,7 @@ parcel Lucy; * * By default, searches return results in order of relevance; SortSpec allows * you to indicate an alternate order via an array of - * L<SortRules|Lucy::Search::SortRule>. + * [SortRules](cfish:SortRule). * * Fields you wish to sort against must be `sortable`. * http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Search/TermQuery.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/TermQuery.cfh b/core/Lucy/Search/TermQuery.cfh index 16d717f..92b1b1c 100644 --- a/core/Lucy/Search/TermQuery.cfh +++ b/core/Lucy/Search/TermQuery.cfh @@ -19,7 +19,7 @@ parcel Lucy; /** Query which matches individual terms. * - * TermQuery is a subclass of L<Lucy::Search::Query> for matching + * TermQuery is a subclass of [](cfish:Query) for matching * individual terms in a specific field. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Store/DirHandle.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/DirHandle.cfh b/core/Lucy/Store/DirHandle.cfh index f300285..581f5d9 100644 --- a/core/Lucy/Store/DirHandle.cfh +++ b/core/Lucy/Store/DirHandle.cfh @@ -50,7 +50,7 @@ abstract class Lucy::Store::DirHandle nickname DH Get_Dir(DirHandle *self); /** Return the path of the current entry. The value is only valid when - * Next() has returned successfully. + * [](cfish:.Next) has returned successfully. */ incremented String* Get_Entry(DirHandle *self); @@ -66,7 +66,7 @@ abstract class Lucy::Store::DirHandle nickname DH abstract bool Entry_Is_Symlink(DirHandle *self); - /** Invokes Close(), but ignores any errors. + /** Invokes [](cfish:.Close), but ignores any errors. */ public void Destroy(DirHandle *self); http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Store/FSFolder.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/FSFolder.cfh b/core/Lucy/Store/FSFolder.cfh index 7d87745..971aa18 100644 --- a/core/Lucy/Store/FSFolder.cfh +++ b/core/Lucy/Store/FSFolder.cfh @@ -18,7 +18,7 @@ parcel Lucy; /** File System implementation of Folder. * - * Implementation of L<Lucy::Store::Folder> using a single file system + * Implementation of [](cfish:Folder) using a single file system * directory and multiple files. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Store/FileHandle.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/FileHandle.cfh b/core/Lucy/Store/FileHandle.cfh index c1a9669..33c788a 100644 --- a/core/Lucy/Store/FileHandle.cfh +++ b/core/Lucy/Store/FileHandle.cfh @@ -125,7 +125,7 @@ abstract class Lucy::Store::FileHandle nickname FH nullable String* Get_Path(FileHandle *self); - /** Invokes Close(), but ignores whether it succeeds or fails. + /** Invokes [](cfish:.Close), but ignores whether it succeeds or fails. */ public void Destroy(FileHandle *self); http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Store/Folder.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/Folder.cfh b/core/Lucy/Store/Folder.cfh index a275e14..6ac2a81 100644 --- a/core/Lucy/Store/Folder.cfh +++ b/core/Lucy/Store/Folder.cfh @@ -19,11 +19,11 @@ parcel Lucy; /** Abstract class representing a directory. * * A "file" within a Folder might be a real file on disk -- or it might be a - * RAM buffer. Similarly, Delete() might delete a file from the file system, or + * RAM buffer. Similarly, [](cfish:.Delete) might delete a file from the file system, or * a key-value pair from a hash, or something else. * * The archetypal implementation of Folder, - * L<FSFolder|Lucy::Store::FSFolder>, represents a directory on + * [](cfish:FSFolder), represents a directory on * the file system holding a collection of files. */ public abstract class Lucy::Store::Folder inherits Clownfish::Obj { http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Store/InStream.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/InStream.cfh b/core/Lucy/Store/InStream.cfh index 4bf7d27..af10d2e 100644 --- a/core/Lucy/Store/InStream.cfh +++ b/core/Lucy/Store/InStream.cfh @@ -119,8 +119,8 @@ class Lucy::Store::InStream inherits Clownfish::Obj { Buf(InStream *self, size_t request); /** Set the buf to a new value, checking for overrun. The idiom is for - * the caller to call Buf(), use no more bytes than requested, then use - * Advance_Buf() to update the InStream object. + * the caller to call [](cfish:.Buf), use no more bytes than requested, then use + * [](cfish:.Advance_Buf) to update the InStream object. */ final void Advance_Buf(InStream *self, const char *buf); http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Store/Lock.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/Lock.cfh b/core/Lucy/Store/Lock.cfh index dcd5fd9..e6496a4 100644 --- a/core/Lucy/Store/Lock.cfh +++ b/core/Lucy/Store/Lock.cfh @@ -43,7 +43,7 @@ public abstract class Lucy::Store::Lock inherits Clownfish::Obj { * consist solely of characters matching [-_.A-Za-z0-9]. * @param host A unique per-machine identifier. * @param timeout Time in milliseconds to keep retrying before abandoning - * the attempt to Obtain() a lock. + * the attempt to [](cfish:.Obtain) a lock. * @param interval Time in milliseconds between retries. */ public inert Lock* @@ -55,7 +55,7 @@ public abstract class Lucy::Store::Lock inherits Clownfish::Obj { public abstract bool Shared(Lock *self); - /** Call Request() once per `interval` until Request() returns + /** Call [](cfish:.Request) once per `interval` until [](cfish:.Request) returns * success or the `timeout` has been reached. * * @return true on success, false on failure (sets Err_error). @@ -65,12 +65,12 @@ public abstract class Lucy::Store::Lock inherits Clownfish::Obj { /** Make one attempt to acquire the lock. * - * The semantics of Request() differ depending on whether Shared() returns - * true. If the Lock is Shared(), then Request() should not fail if + * The semantics of [](cfish:.Request) differ depending on whether [](cfish:.Shared) returns + * true. If the Lock is [](cfish:.Shared), then [](cfish:.Request) should not fail if * another lock is held against the resource identified by * `name` (though it might fail for other reasons). If it is - * not Shared() -- i.e. it's an exclusive (write) lock -- then other locks - * should cause Request() to fail. + * not [](cfish:.Shared) -- i.e. it's an exclusive (write) lock -- then other locks + * should cause [](cfish:.Request) to fail. * * @return true on success, false on failure (sets Err_error). */ @@ -157,7 +157,7 @@ class Lucy::Store::LockFileLock nickname LFLock /** Lock exception. * - * LockErr is a subclass of L<Err|Clownfish::Err> which indicates + * LockErr is a subclass of [Err](cfish:cfish.Err) which indicates * that a file locking problem occurred. */ public class Lucy::Store::LockErr inherits Clownfish::Err { http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Store/LockFactory.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/LockFactory.cfh b/core/Lucy/Store/LockFactory.cfh index 5cf8232..0feb459 100644 --- a/core/Lucy/Store/LockFactory.cfh +++ b/core/Lucy/Store/LockFactory.cfh @@ -34,33 +34,33 @@ public class Lucy::Store::LockFactory nickname LockFact new(Folder *folder, String *host); /** - * @param folder A L<Lucy::Store::Folder>. + * @param folder A [](cfish:Folder). * @param host An identifier which should be unique per-machine. */ public inert LockFactory* init(LockFactory *self, Folder *folder, String *host); - /** Return a Lock object, which, once Obtain() returns successfully, + /** Return a Lock object, which, once [](cfish:Lock.Obtain) returns successfully, * maintains an exclusive lock on a resource. * * @param name A file-system-friendly id which identifies the * resource to be locked. * @param timeout Time in milliseconds to keep retrying before abandoning - * the attempt to Obtain() a lock. + * the attempt to [](cfish:Lock.Obtain) a lock. * @param interval Time in milliseconds between retries. */ public incremented Lock* Make_Lock(LockFactory *self, String *name, int32_t timeout = 0, int32_t interval = 100); - /** Return a Lock object for which Shared() returns true, and which - * maintains a non-exclusive lock on a resource once Obtain() returns + /** Return a Lock object for which [](cfish:Lock.Shared) returns true, and which + * maintains a non-exclusive lock on a resource once [](cfish:Lock.Obtain) returns * success. * * @param name A file-system-friendly id which identifies the * resource to be locked. * @param timeout Time in milliseconds to keep retrying before abandoning - * the attempt to Obtain() a lock. + * the attempt to [](cfish:Lock.Obtain) a lock. * @param interval Time in milliseconds between retries. */ public incremented Lock* http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Store/RAMFolder.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/RAMFolder.cfh b/core/Lucy/Store/RAMFolder.cfh index c04267d..c3e5964 100644 --- a/core/Lucy/Store/RAMFolder.cfh +++ b/core/Lucy/Store/RAMFolder.cfh @@ -19,7 +19,7 @@ parcel Lucy; /** In-memory Folder implementation. * * RAMFolder is an entirely in-memory implementation of - * L<Lucy::Store::Folder>, primarily used for testing and development. + * [](cfish:Folder), primarily used for testing and development. */ public class Lucy::Store::RAMFolder inherits Lucy::Store::Folder { http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Store/SharedLock.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/SharedLock.cfh b/core/Lucy/Store/SharedLock.cfh index e409e79..ba0fca2 100644 --- a/core/Lucy/Store/SharedLock.cfh +++ b/core/Lucy/Store/SharedLock.cfh @@ -19,17 +19,17 @@ parcel Lucy; /** Shared (read) lock. * * SharedLock's interface is nearly identical to that of its parent class - * L<Lucy::Store::Lock>, taking the same constructor arguments and + * [](cfish:Lock), taking the same constructor arguments and * implementing the same list of methods. It differs from Lock only in the * semantics of two methods. * - * First, Obtain() will not fail if another lock is held against the resource + * First, [](cfish:.Obtain) will not fail if another lock is held against the resource * identified by `name` (though it might fail for other reasons). * - * Second, Is_Locked() returns true so long as some lock, somewhere is holding + * Second, [](cfish:.Is_Locked) returns true so long as some lock, somewhere is holding * a lock on `name`. That lock could be this instance, or it could - * be another -- so is entirely possible to call Release() successfully on a - * SharedLock object yet still have Is_Locked() return true. + * be another -- so is entirely possible to call [](cfish:.Release) successfully on a + * SharedLock object yet still have [](cfish:.Is_Locked) return true. * * As currently implemented, SharedLock differs from Lock in that each caller * gets its own lockfile. Lockfiles still have filenames which begin with the @@ -51,7 +51,7 @@ class Lucy::Store::SharedLock nickname ShLock * @param name String identifying the resource to be locked. * @param host An identifier which should be unique per-machine. * @param timeout Time in milliseconds to keep retrying before abandoning - * the attempt to Obtain() a lock. + * the attempt to [](cfish:.Obtain) a lock. * @param interval Time in milliseconds between retries. */ public inert SharedLock* http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Test/Plan/TestArchitecture.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Test/Plan/TestArchitecture.cfh b/core/Lucy/Test/Plan/TestArchitecture.cfh index d86b1b8..dafd5e7 100644 --- a/core/Lucy/Test/Plan/TestArchitecture.cfh +++ b/core/Lucy/Test/Plan/TestArchitecture.cfh @@ -17,7 +17,7 @@ parcel TestLucy; /** - * Returns absurdly low values for Index_Interval() and Skip_Interval(). + * Returns absurdly low values for [](cfish:.Index_Interval) and [](cfish:.Skip_Interval). */ class Lucy::Test::Plan::TestArchitecture nickname TestArch http://git-wip-us.apache.org/repos/asf/lucy/blob/500e7ae7/core/Lucy/Test/TestSchema.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Test/TestSchema.cfh b/core/Lucy/Test/TestSchema.cfh index 87dd41a..5cd897a 100644 --- a/core/Lucy/Test/TestSchema.cfh +++ b/core/Lucy/Test/TestSchema.cfh @@ -19,7 +19,7 @@ parcel TestLucy; /** Schema for use by the test suite. * * Exposes problems faced by much larger indexes by using an TestArchitecture, - * which returns absurdly low values for Index_Interval() and Skip_Interval(). + * which returns absurdly low values for [](cfish:.Index_Interval) and [](cfish:.Skip_Interval). */ class Lucy::Test::TestSchema inherits Lucy::Plan::Schema {
