You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucy.apache.org by nw...@apache.org on 2014/12/04 22:46:21 UTC
[2/2] lucy git commit: Convert cfish URIs to new syntax
Convert cfish URIs to new syntax
Project: http://git-wip-us.apache.org/repos/asf/lucy/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucy/commit/af11daf0
Tree: http://git-wip-us.apache.org/repos/asf/lucy/tree/af11daf0
Diff: http://git-wip-us.apache.org/repos/asf/lucy/diff/af11daf0
Branch: refs/heads/markdown
Commit: af11daf0bb6c8fcb98fc3de5b4891fa1bcdedacf
Parents: 82d3866
Author: Nick Wellnhofer <we...@aevum.de>
Authored: Thu Dec 4 18:26:27 2014 +0100
Committer: Nick Wellnhofer <we...@aevum.de>
Committed: Thu Dec 4 18:26:27 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/af11daf0/core/Lucy/Analysis/Analyzer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/Analyzer.cfh b/core/Lucy/Analysis/Analyzer.cfh
index a9b868d..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 ([RegexTokenizer](clownfish:class:RegexTokenizer)), or it
+ * smaller pieces ([](cfish:RegexTokenizer)), or it
* might perform case folding to facilitate case-insensitive search
- * ([Normalizer](clownfish:class:Normalizer)).
+ * ([](cfish:Normalizer)).
*/
public abstract class Lucy::Analysis::Analyzer inherits Clownfish::Obj {
public inert Analyzer*
init(Analyzer *self);
- /** Take a single [Inversion](clownfish:class: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()](clownfish:method: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/af11daf0/core/Lucy/Analysis/CaseFolder.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/CaseFolder.cfh b/core/Lucy/Analysis/CaseFolder.cfh
index d42cfa1..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 [Normalizer](clownfish:class: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/af11daf0/core/Lucy/Analysis/EasyAnalyzer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/EasyAnalyzer.cfh b/core/Lucy/Analysis/EasyAnalyzer.cfh
index d138767..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
- * [StandardTokenizer](clownfish:class:StandardTokenizer), a
- * [Normalizer](clownfish:class:Normalizer), and a
- * [SnowballStemmer](clownfish:class:SnowballStemmer).
+ * [](cfish:StandardTokenizer), a
+ * [](cfish:Normalizer), and a
+ * [](cfish:SnowballStemmer).
*
* Supported languages:
*
http://git-wip-us.apache.org/repos/asf/lucy/blob/af11daf0/core/Lucy/Analysis/Normalizer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/Normalizer.cfh b/core/Lucy/Analysis/Normalizer.cfh
index 9f49e6a..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 [Analyzer](clownfish:class: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/af11daf0/core/Lucy/Analysis/PolyAnalyzer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/PolyAnalyzer.cfh b/core/Lucy/Analysis/PolyAnalyzer.cfh
index e0946ae..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 [Analyzers](clownfish:class: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
- * [CaseFolder](clownfish:class:CaseFolder), a
- * [RegexTokenizer](clownfish:class:RegexTokenizer), and a
- * [SnowballStemmer](clownfish:class: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
- * [EasyAnalyzer](clownfish:class: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 [EasyAnalyzer](clownfish:class: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/af11daf0/core/Lucy/Analysis/SnowballStemmer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/SnowballStemmer.cfh b/core/Lucy/Analysis/SnowballStemmer.cfh
index e3ea345..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 [Analyzer](clownfish:class: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/af11daf0/core/Lucy/Analysis/Token.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/Token.cfh b/core/Lucy/Analysis/Token.cfh
index 4d6c60f..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
- * [RichPosting](clownfish:class: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/af11daf0/core/Lucy/Docs/FileLocking.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Docs/FileLocking.cfh b/core/Lucy/Docs/FileLocking.cfh
index 5536477..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()](clownfish:method:Indexer: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()](clownfish:method:LockFactory: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()](clownfish:method:LockFactory: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/af11daf0/core/Lucy/Highlight/Highlighter.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Highlight/Highlighter.cfh b/core/Lucy/Highlight/Highlighter.cfh
index fef2656..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
- * [Searcher](clownfish:class:Searcher), such as an
- * [IndexSearcher](clownfish:class: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
- * [FieldType](clownfish:class: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()](clownfish:method: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()](clownfish:method: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/af11daf0/core/Lucy/Index/BackgroundMerger.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/BackgroundMerger.cfh b/core/Lucy/Index/BackgroundMerger.cfh
index b281f37..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 [Indexer](clownfish:class: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()](clownfish:method: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()](clownfish:method:Commit) in advance, so that [Commit()](clownfish:method:Commit)
+ /** Perform the expensive setup for [](cfish:.Commit) in advance, so that [](cfish:.Commit)
* completes quickly.
*
- * Towards the end of [Prepare_Commit()](clownfish:method:Prepare_Commit), the BackgroundMerger attempts to
- * re-acquire the write lock, which is then held until [Commit()](clownfish:method: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/af11daf0/core/Lucy/Index/DataReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DataReader.cfh b/core/Lucy/Index/DataReader.cfh
index b800702..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
- * [DataWriter](clownfish:class: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/af11daf0/core/Lucy/Index/DataWriter.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DataWriter.cfh b/core/Lucy/Index/DataWriter.cfh
index 26e6033..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/[DataReader](clownfish:class:DataReader) pair.
+ * DataWriter/[](cfish:DataReader) pair.
*
* Components may be specified per index by subclassing
- * [Architecture](clownfish:class: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()](clownfish:method:Add_Segment) then [Delete_Segment()](clownfish:method: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/af11daf0/core/Lucy/Index/DeletionsWriter.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DeletionsWriter.cfh b/core/Lucy/Index/DeletionsWriter.cfh
index 1da9aae..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 [Query](clownfish:class: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/af11daf0/core/Lucy/Index/DocReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DocReader.cfh b/core/Lucy/Index/DocReader.cfh
index 917447d..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
- * [HitDoc](clownfish:class:HitDoc) objects.
+ * [](cfish:HitDoc) objects.
*/
public class Lucy::Index::DocReader inherits Lucy::Index::DataReader {
http://git-wip-us.apache.org/repos/asf/lucy/blob/af11daf0/core/Lucy/Index/IndexManager.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/IndexManager.cfh b/core/Lucy/Index/IndexManager.cfh
index 5d6672d..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 [Architecture](clownfish:class: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/af11daf0/core/Lucy/Index/IndexReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/IndexReader.cfh b/core/Lucy/Index/IndexReader.cfh
index 10e7957..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
- * [IndexSearcher](clownfish:class: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
- * [DataReader](clownfish:class:DataReader) sub-components, which may be
- * accessed via [Fetch()](clownfish:method:Fetch) and [Obtain()](clownfish:method: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
- * [SegReader](clownfish:class: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 [IndexManager](clownfish:class: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/af11daf0/core/Lucy/Index/Indexer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/Indexer.cfh b/core/Lucy/Index/Indexer.cfh
index 4ac2441..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
- * [IndexSearcher](clownfish:class: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
- * [IndexManager](clownfish:class: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()](clownfish:method:Delete_By_Term) and [Delete_By_Query()](clownfish:method: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()](clownfish:method: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 [Query](clownfish:class: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()](clownfish:method: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()](clownfish:method:Optimize) method causes all existing index content to be fed back
- * into the Indexer. When [Commit()](clownfish:method:Commit) completes after an [Optimize()](clownfish:method:Optimize), the
- * index will consist of one segment. So [Optimize()](clownfish:method:Optimize) must be called
- * before [Commit()](clownfish:method: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()](clownfish:method: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()](clownfish:method: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()](clownfish:method:Commit) in advance, so that [Commit()](clownfish:method:Commit)
- * completes quickly. (If [Prepare_Commit()](clownfish:method:Prepare_Commit) is not called explicitly by
- * the user, [Commit()](clownfish:method: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/af11daf0/core/Lucy/Index/Inverter.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/Inverter.cfh b/core/Lucy/Index/Inverter.cfh
index f635443..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()](clownfish:method:Set_Doc), then [Add_Field()](clownfish:method: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()](clownfish:method: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()](clownfish:method: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/af11daf0/core/Lucy/Index/Lexicon.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/Lexicon.cfh b/core/Lucy/Index/Lexicon.cfh
index e14d71f..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()](clownfish:method: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/af11daf0/core/Lucy/Index/PolyReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/PolyReader.cfh b/core/Lucy/Index/PolyReader.cfh
index 8418640..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()](clownfish:method:Doc_Max) method will return 30.
+ * [](cfish:.Doc_Max) method will return 30.
*
- * Some of PolyReader's [DataReader](clownfish:class:DataReader) components
+ * Some of PolyReader's [](cfish:DataReader) components
* may be less efficient or complete than the single-segment implementations
- * accessed via [SegReader](clownfish:class: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 [Folder](clownfish:class: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 [IndexManager](clownfish:class: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/af11daf0/core/Lucy/Index/Posting.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/Posting.cfh b/core/Lucy/Index/Posting.cfh
index 836e9c2..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
- * [MatchPosting](clownfish:class:MatchPosting), the simplest
+ * [](cfish:MatchPosting), the simplest
* posting format, and
- * [ScorePosting](clownfish:class: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/af11daf0/core/Lucy/Index/Posting/RichPosting.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/Posting/RichPosting.cfh b/core/Lucy/Index/Posting/RichPosting.cfh
index 0720e37..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
- * [ScorePosting](clownfish:class:ScorePosting), but weighting is
+ * [](cfish:ScorePosting), but weighting is
* per-position rather than per-field. To exploit this, you need a custom
- * [Analyzer](clownfish:class:Analyzer) which assigns varying boosts to
- * individual [Token](clownfish:class: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/af11daf0/core/Lucy/Index/PostingList.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/PostingList.cfh b/core/Lucy/Index/PostingList.cfh
index 3bd7352..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()](clownfish:method: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/af11daf0/core/Lucy/Index/PostingListReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/PostingListReader.cfh b/core/Lucy/Index/PostingListReader.cfh
index b2ab868..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 [PostingList](clownfish:class: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()](clownfish:method:PostingList: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/af11daf0/core/Lucy/Index/SegPostingList.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/SegPostingList.cfh b/core/Lucy/Index/SegPostingList.cfh
index 9a81c30..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()](clownfish:method: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/af11daf0/core/Lucy/Index/SegReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/SegReader.cfh b/core/Lucy/Index/SegReader.cfh
index 428de8d..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 [Architecture](clownfish:class:Architecture)'s
+ * components spawned by [](cfish:Architecture)'s
* factory methods.
*/
http://git-wip-us.apache.org/repos/asf/lucy/blob/af11daf0/core/Lucy/Index/SegWriter.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/SegWriter.cfh b/core/Lucy/Index/SegWriter.cfh
index 07d96d7..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 [Segment](clownfish:class:Segment) and Inverter, invokes the
- * [Analyzer](clownfish:class:Analyzer) chain, and feeds low
- * level [DataWriters](clownfish:class: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
- * [Architecture](clownfish:class:Architecture). DataWriter components
- * which are added to the stack of writers via [Add_Writer()](clownfish:method:Add_Writer) have
- * [Add_Inverted_Doc()](clownfish:method:Add_Inverted_Doc) invoked for each document supplied to SegWriter's
- * [Add_Doc()](clownfish:method: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()](clownfish:method:Fetch), so you may
- * also want to call [Add_Writer()](clownfish:method: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()](clownfish:method: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/af11daf0/core/Lucy/Index/Snapshot.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/Snapshot.cfh b/core/Lucy/Index/Snapshot.cfh
index f0c1bd9..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.
*
- * [IndexReader](clownfish:class: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()](clownfish:method:Read_File), [Write_File()](clownfish:method:Write_File), and [Set_Path()](clownfish:method: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/af11daf0/core/Lucy/Plan/Architecture.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Plan/Architecture.cfh b/core/Lucy/Plan/Architecture.cfh
index 34cefb8..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
- * [SegWriter](clownfish:class:SegWriter) and
- * [SegReader](clownfish:class: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()](clownfish:method:SegWriter: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()](clownfish:method:SegWriter: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()](clownfish:method:SegWriter: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()](clownfish:method:SegWriter: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()](clownfish:method:SegWriter: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()](clownfish:method:SegWriter:Register) it with the supplied SegWriter,
- * also calling [Set_Del_Writer()](clownfish:method:SegWriter: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()](clownfish:method:SegReader: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()](clownfish:method:SegReader: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()](clownfish:method:SegReader: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()](clownfish:method:SegReader: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()](clownfish:method:SegReader: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()](clownfish:method:SegReader: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/af11daf0/core/Lucy/Plan/FieldType.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Plan/FieldType.cfh b/core/Lucy/Plan/FieldType.cfh
index 7da470b..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
- * [Similarity](clownfish:class: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()](clownfish:method: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/af11daf0/core/Lucy/Plan/FullTextType.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Plan/FullTextType.cfh b/core/Lucy/Plan/FullTextType.cfh
index f358635..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
- * [FieldType](clownfish:class:FieldType) tuned for "full text search".
+ * [](cfish:FieldType) tuned for "full text search".
*
* Full text fields are associated with an
- * [Analyzer](clownfish:class: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
- * [StringType](clownfish:class: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
- * [Highlighter](clownfish:class: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/af11daf0/core/Lucy/Plan/Schema.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Plan/Schema.cfh b/core/Lucy/Plan/Schema.cfh
index 017ac7f..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()](clownfish:method: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/af11daf0/core/Lucy/Search/ANDQuery.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/ANDQuery.cfh b/core/Lucy/Search/ANDQuery.cfh
index 6322e67..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 [Query](clownfish:class: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/af11daf0/core/Lucy/Search/Collector.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/Collector.cfh b/core/Lucy/Search/Collector.cfh
index b260bd3..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
- * [Matcher](clownfish:class:Matcher) iterates through, based on how the
- * abstract [Collect()](clownfish:method: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()](clownfish:method:Set_Reader), [Set_Base()](clownfish:method:Set_Base) and [Set_Matcher()](clownfish:method: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()](clownfish:method: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()](clownfish:method:Matcher: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
- * [BitVector](clownfish:class: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/af11daf0/core/Lucy/Search/Collector/SortCollector.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/Collector/SortCollector.cfh b/core/Lucy/Search/Collector/SortCollector.cfh
index 88757d0..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()](clownfish:method: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/af11daf0/core/Lucy/Search/Compiler.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/Compiler.cfh b/core/Lucy/Search/Compiler.cfh
index cab0286..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 [Query](clownfish:class:Query) object and compile a
- * [Matcher](clownfish:class: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()](clownfish:method: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()](clownfish:method:Get_Weight), [Sum_Of_Squared_Weights()](clownfish:method:Sum_Of_Squared_Weights), and
- * [Apply_Norm_Factor()](clownfish:method: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 [Searcher](clownfish:class: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()](clownfish:method:Make_Matcher), method, which is where
- * the Compiler meets a [SegReader](clownfish:class: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()](clownfish:method: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()](clownfish:method:Matcher: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()](clownfish:method: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()](clownfish:method: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()](clownfish:method: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/af11daf0/core/Lucy/Search/IndexSearcher.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/IndexSearcher.cfh b/core/Lucy/Search/IndexSearcher.cfh
index 0115318..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
- * [PolySearcher](clownfish:class:PolySearcher)).
+ * [](cfish:PolySearcher)).
*
* IndexSearchers operate against a single point-in-time view or
- * [Snapshot](clownfish:class: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/af11daf0/core/Lucy/Search/LeafQuery.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/LeafQuery.cfh b/core/Lucy/Search/LeafQuery.cfh
index 586e407..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
- * [QueryParser](clownfish:class:QueryParser)'s [Tree()](clownfish:method:QueryParser:Tree) method.
+ * [](cfish:QueryParser)'s [](cfish:QueryParser.Tree) method.
* Ultimately, they must be transformed, typically into either
- * [TermQuery](clownfish:class:TermQuery) or
- * [PhraseQuery](clownfish:class: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/af11daf0/core/Lucy/Search/Matcher.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/Matcher.cfh b/core/Lucy/Search/Matcher.cfh
index 3bd1d4c..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()](clownfish:method: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()](clownfish:method: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()](clownfish:method:Next) or [Advance()](clownfish:method: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()](clownfish:method: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/af11daf0/core/Lucy/Search/NOTQuery.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/NOTQuery.cfh b/core/Lucy/Search/NOTQuery.cfh
index 730f900..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 [Query](clownfish:class: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
- * [ANDQuery](clownfish:class: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/af11daf0/core/Lucy/Search/NoMatchQuery.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/NoMatchQuery.cfh b/core/Lucy/Search/NoMatchQuery.cfh
index 080b4a6..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
- * [QueryParser](clownfish:class: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/af11daf0/core/Lucy/Search/ORMatcher.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/ORMatcher.cfh b/core/Lucy/Search/ORMatcher.cfh
index a97d29b..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()](clownfish:method: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/af11daf0/core/Lucy/Search/ORQuery.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/ORQuery.cfh b/core/Lucy/Search/ORQuery.cfh
index 5be0dce..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 [Query](clownfish:class: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/af11daf0/core/Lucy/Search/PhraseQuery.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/PhraseQuery.cfh b/core/Lucy/Search/PhraseQuery.cfh
index aeafac2..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 [Query](clownfish:class: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/af11daf0/core/Lucy/Search/PolyQuery.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/PolyQuery.cfh b/core/Lucy/Search/PolyQuery.cfh
index 8dcbde8..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
- * [ANDQuery](clownfish:class:ANDQuery),
- * [ORQuery](clownfish:class:ORQuery),
- * [NOTQuery](clownfish:class:NOTQuery), and
- * [RequiredOptionalQuery](clownfish:class: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/af11daf0/core/Lucy/Search/Query.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/Query.cfh b/core/Lucy/Search/Query.cfh
index 56a7aa5..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 [QueryParser's](clownfish:class:QueryParser)
- * [Parse()](clownfish:method:QueryParser:Parse) method, which outputs an abstract syntax tree built up from various
- * Query subclasses such as [ANDQuery](clownfish:class:ANDQuery) and
- * [TermQuery](clownfish:class: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()](clownfish:method:Make_Compiler), which is the first step
- * in compiling a Query down to a [Matcher](clownfish:class: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()](clownfish:method:Compiler: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/af11daf0/core/Lucy/Search/QueryParser.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/QueryParser.cfh b/core/Lucy/Search/QueryParser.cfh
index 4fcd3d2..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
- * [Query](clownfish:class:Query) objects, suitable for feeding into
- * [IndexSearcher](clownfish:class:IndexSearcher) and other
- * [Searcher](clownfish:class: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()](clownfish:method: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 [Schema](clownfish:class:Schema).
- * @param analyzer An [Analyzer](clownfish:class: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()](clownfish:method:Tree), [Expand()](clownfish:method:Expand), and [Prune()](clownfish:method: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()](clownfish:method:Tree) is an intermediate form which must be passed
- * through [Expand()](clownfish:method: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()](clownfish:method: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()](clownfish:method:Tree) and [Expand()](clownfish:method: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()](clownfish:method: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()](clownfish:method: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()](clownfish:method:Tree) then [Expand()](clownfish:method:Expand),
- * skipping [Prune()](clownfish:method: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/af11daf0/core/Lucy/Search/Searcher.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/Searcher.cfh b/core/Lucy/Search/Searcher.cfh
index f4aa257..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
- * [IndexSearcher](clownfish:class:IndexSearcher) and
- * [PolySearcher](clownfish:class: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 [SortSpec](clownfish:class: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
- * [Collector](clownfish:class:Collector).
+ * [](cfish:Collector).
*
* @param query A Query.
* @param collector A Collector.
http://git-wip-us.apache.org/repos/asf/lucy/blob/af11daf0/core/Lucy/Search/SortRule.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/SortRule.cfh b/core/Lucy/Search/SortRule.cfh
index 080a87d..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
- * [SortSpecs](clownfish:class: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/af11daf0/core/Lucy/Search/SortSpec.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/SortSpec.cfh b/core/Lucy/Search/SortSpec.cfh
index 2df63aa..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
- * [SortRules](clownfish:class:SortRule).
+ * [SortRules](cfish:SortRule).
*
* Fields you wish to sort against must be `sortable`.
*
http://git-wip-us.apache.org/repos/asf/lucy/blob/af11daf0/core/Lucy/Search/TermQuery.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Search/TermQuery.cfh b/core/Lucy/Search/TermQuery.cfh
index 082acd2..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 [Query](clownfish:class: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/af11daf0/core/Lucy/Store/DirHandle.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/DirHandle.cfh b/core/Lucy/Store/DirHandle.cfh
index c0e1e28..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()](clownfish:method: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()](clownfish:method: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/af11daf0/core/Lucy/Store/FSFolder.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/FSFolder.cfh b/core/Lucy/Store/FSFolder.cfh
index 78b4948..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 [Folder](clownfish:class: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/af11daf0/core/Lucy/Store/FileHandle.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/FileHandle.cfh b/core/Lucy/Store/FileHandle.cfh
index 4d7664d..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()](clownfish:method: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/af11daf0/core/Lucy/Store/Folder.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/Folder.cfh b/core/Lucy/Store/Folder.cfh
index 661bf1c..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()](clownfish:method: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,
- * [FSFolder](clownfish:class: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/af11daf0/core/Lucy/Store/InStream.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/InStream.cfh b/core/Lucy/Store/InStream.cfh
index c0a6516..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()](clownfish:method:Buf), use no more bytes than requested, then use
- * [Advance_Buf()](clownfish:method: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/af11daf0/core/Lucy/Store/Lock.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/Lock.cfh b/core/Lucy/Store/Lock.cfh
index 59eab09..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()](clownfish:method: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()](clownfish:method:Request) once per `interval` until [Request()](clownfish:method: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()](clownfish:method:Request) differ depending on whether [Shared()](clownfish:method:Shared) returns
- * true. If the Lock is [Shared()](clownfish:method:Shared), then [Request()](clownfish:method: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()](clownfish:method:Shared) -- i.e. it's an exclusive (write) lock -- then other locks
- * should cause [Request()](clownfish:method: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 [Err](clownfish:class:cfish: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/af11daf0/core/Lucy/Store/LockFactory.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Store/LockFactory.cfh b/core/Lucy/Store/LockFactory.cfh
index d68e008..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 [Folder](clownfish:class: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()](clownfish:method:Lock: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()](clownfish:method:Lock: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()](clownfish:method:Lock:Shared) returns true, and which
- * maintains a non-exclusive lock on a resource once [Obtain()](clownfish:method:Lock: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()](clownfish:method:Lock:Obtain) a lock.
+ * the attempt to [](cfish:Lock.Obtain) a lock.
* @param interval Time in milliseconds between retries.
*/
public incremented Lock*