Convert POD links to Markdown 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/4a6f325a Tree: http://git-wip-us.apache.org/repos/asf/lucy/tree/4a6f325a Diff: http://git-wip-us.apache.org/repos/asf/lucy/diff/4a6f325a Branch: refs/heads/markdown Commit: 4a6f325ab37205dda60559d02a37470de5034ed2 Parents: 4db9338 Author: Nick Wellnhofer <[email protected]> Authored: Mon Nov 10 00:47:29 2014 +0100 Committer: Nick Wellnhofer <[email protected]> Committed: Tue Nov 11 17:13:17 2014 +0100 ---------------------------------------------------------------------- core/Lucy/Analysis/Analyzer.cfh | 6 +++--- 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/Highlight/Highlighter.cfh | 6 +++--- core/Lucy/Index/BackgroundMerger.cfh | 2 +- core/Lucy/Index/DataReader.cfh | 2 +- core/Lucy/Index/DataWriter.cfh | 4 ++-- core/Lucy/Index/DeletionsWriter.cfh | 2 +- core/Lucy/Index/DocReader.cfh | 2 +- core/Lucy/Index/IndexManager.cfh | 2 +- core/Lucy/Index/IndexReader.cfh | 8 ++++---- core/Lucy/Index/Indexer.cfh | 6 +++--- core/Lucy/Index/PolyReader.cfh | 8 ++++---- core/Lucy/Index/Posting.cfh | 4 ++-- core/Lucy/Index/Posting/RichPosting.cfh | 6 +++--- core/Lucy/Index/PostingListReader.cfh | 2 +- core/Lucy/Index/SegReader.cfh | 2 +- core/Lucy/Index/SegWriter.cfh | 8 ++++---- core/Lucy/Index/Snapshot.cfh | 2 +- core/Lucy/Plan/Architecture.cfh | 4 ++-- core/Lucy/Plan/FieldType.cfh | 2 +- core/Lucy/Plan/FullTextType.cfh | 8 ++++---- core/Lucy/Search/ANDQuery.cfh | 2 +- core/Lucy/Search/Collector.cfh | 4 ++-- core/Lucy/Search/Compiler.cfh | 8 ++++---- core/Lucy/Search/IndexSearcher.cfh | 4 ++-- core/Lucy/Search/LeafQuery.cfh | 6 +++--- core/Lucy/Search/NOTQuery.cfh | 4 ++-- core/Lucy/Search/NoMatchQuery.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 | 8 ++++---- core/Lucy/Search/QueryParser.cfh | 10 +++++----- 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/FSFolder.cfh | 2 +- core/Lucy/Store/Folder.cfh | 2 +- core/Lucy/Store/Lock.cfh | 2 +- core/Lucy/Store/LockFactory.cfh | 2 +- core/Lucy/Store/RAMFolder.cfh | 2 +- core/Lucy/Store/SharedLock.cfh | 2 +- core/LucyX/Search/ProximityQuery.cfh | 2 +- 49 files changed, 100 insertions(+), 100 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Analysis/Analyzer.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Analysis/Analyzer.cfh b/core/Lucy/Analysis/Analyzer.cfh index 486ebc2..1c9136f 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 ([RegexTokenizer](clownfish:class:lucy:RegexTokenizer)), or it * might perform case folding to facilitate case-insensitive search - * (L<Normalizer|Lucy::Analysis::Normalizer>). + * ([Normalizer](clownfish:class:lucy: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 [Inversion](clownfish:class:lucy:Inversion) as input * and returns an Inversion, either the same one (presumably transformed * in some way), or a new one. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Analysis/CaseFolder.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Analysis/CaseFolder.cfh b/core/Lucy/Analysis/CaseFolder.cfh index cce788b..50b558d 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 [Normalizer](clownfish:class:lucy:Normalizer) * instead. * * CaseFolder normalizes text according to Unicode case-folding rules, so that http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Analysis/EasyAnalyzer.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Analysis/EasyAnalyzer.cfh b/core/Lucy/Analysis/EasyAnalyzer.cfh index 905f914..34352ea 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>. + * [StandardTokenizer](clownfish:class:lucy:StandardTokenizer), a + * [Normalizer](clownfish:class:lucy:Normalizer), and a + * [SnowballStemmer](clownfish:class:lucy:SnowballStemmer). * * Supported languages: * http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Analysis/Normalizer.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Analysis/Normalizer.cfh b/core/Lucy/Analysis/Normalizer.cfh index f46ee63..53cf3f4 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 [Analyzer](clownfish:class:lucy: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/4a6f325a/core/Lucy/Analysis/PolyAnalyzer.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Analysis/PolyAnalyzer.cfh b/core/Lucy/Analysis/PolyAnalyzer.cfh index 5108259..f962f42 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](clownfish:class:lucy: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. + * [CaseFolder](clownfish:class:lucy:CaseFolder), a + * [RegexTokenizer](clownfish:class:lucy:RegexTokenizer), and a + * [SnowballStemmer](clownfish:class:lucy:SnowballStemmer) will be generated for you. * * The language parameter is DEPRECATED. Use - * L<EasyAnalyzer|Lucy::Analysis::EasyAnalyzer> instead. + * [EasyAnalyzer](clownfish:class:lucy: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 [EasyAnalyzer](clownfish:class:lucy: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/4a6f325a/core/Lucy/Analysis/SnowballStemmer.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Analysis/SnowballStemmer.cfh b/core/Lucy/Analysis/SnowballStemmer.cfh index 4fe92a0..cebb7a0 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 [Analyzer](clownfish:class:lucy: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/4a6f325a/core/Lucy/Analysis/Token.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Analysis/Token.cfh b/core/Lucy/Analysis/Token.cfh index 831f360..f3058e8 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>.) + * [RichPosting](clownfish:class:lucy: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/4a6f325a/core/Lucy/Highlight/Highlighter.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Highlight/Highlighter.cfh b/core/Lucy/Highlight/Highlighter.cfh index 72010c0..edbe1cd 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>. + * [Searcher](clownfish:class:lucy:Searcher), such as an + * [IndexSearcher](clownfish:class:lucy: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>). + * [FieldType](clownfish:class:lucy:FieldType)). * @param excerpt_length Maximum length of the excerpt, in characters. */ public inert Highlighter* http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Index/BackgroundMerger.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/BackgroundMerger.cfh b/core/Lucy/Index/BackgroundMerger.cfh index 9804de8..024a02d 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 [Indexer](clownfish:class:lucy:Indexer), see * L<Lucy::Docs::FileLocking> if your index is on a shared volume. */ public class Lucy::Index::BackgroundMerger nickname BGMerger http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Index/DataReader.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/DataReader.cfh b/core/Lucy/Index/DataReader.cfh index f5f9988..721e876 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 + * [DataWriter](clownfish:class:lucy:DataWriter). Every index component will * implement one of each. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Index/DataWriter.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/DataWriter.cfh b/core/Lucy/Index/DataWriter.cfh index efbb716..daf62a5 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/[DataReader](clownfish:class:lucy:DataReader) pair. * * Components may be specified per index by subclassing - * L<Architecture|Lucy::Plan::Architecture>. + * [Architecture](clownfish:class:lucy:Architecture). */ public class Lucy::Index::DataWriter inherits Clownfish::Obj { http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Index/DeletionsWriter.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/DeletionsWriter.cfh b/core/Lucy/Index/DeletionsWriter.cfh index 140e374..634d1fe 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 [Query](clownfish:class:lucy:Query). */ public abstract void Delete_By_Query(DeletionsWriter *self, Query *query); http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Index/DocReader.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/DocReader.cfh b/core/Lucy/Index/DocReader.cfh index 182e2e3..07ccf3c 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. + * [HitDoc](clownfish:class:lucy:HitDoc) objects. */ public class Lucy::Index::DocReader inherits Lucy::Index::DataReader { http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Index/IndexManager.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/IndexManager.cfh b/core/Lucy/Index/IndexManager.cfh index 03795cd..5c29a09 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 [Architecture](clownfish:class:lucy: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/4a6f325a/core/Lucy/Index/IndexReader.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/IndexReader.cfh b/core/Lucy/Index/IndexReader.cfh index 80d7584..9997a32 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 + * [IndexSearcher](clownfish:class:lucy: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 + * [DataReader](clownfish:class:lucy:DataReader) sub-components, which may be * accessed via Fetch() and Obtain(). The most efficient and powerful access * to index data happens at the segment level via - * L<SegReader|Lucy::Index::SegReader>'s sub-components. + * [SegReader](clownfish:class:lucy: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 [IndexManager](clownfish:class:lucy: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/4a6f325a/core/Lucy/Index/Indexer.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/Indexer.cfh b/core/Lucy/Index/Indexer.cfh index 20dccf3..c5524f3 100644 --- a/core/Lucy/Index/Indexer.cfh +++ b/core/Lucy/Index/Indexer.cfh @@ -20,14 +20,14 @@ 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>. + * [IndexSearcher](clownfish:class:lucy: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 + * [IndexManager](clownfish:class:lucy:IndexManager) with a unique * `host` id to Indexer's constructor or index corruption will * occur. See L<Lucy::Docs::FileLocking> for a detailed discussion. * @@ -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 [Query](clownfish:class:lucy:Query). */ public void Delete_By_Query(Indexer *self, Query *query); http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Index/PolyReader.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/PolyReader.cfh b/core/Lucy/Index/PolyReader.cfh index 6624c7a..cd39c99 100644 --- a/core/Lucy/Index/PolyReader.cfh +++ b/core/Lucy/Index/PolyReader.cfh @@ -22,9 +22,9 @@ parcel Lucy; * an index contains three segments with 10 documents each, PolyReader's * Doc_Max() method will return 30. * - * Some of PolyReader's L<DataReader|Lucy::Index::DataReader> components + * Some of PolyReader's [DataReader](clownfish:class:lucy:DataReader) components * may be less efficient or complete than the single-segment implementations - * accessed via L<SegReader|Lucy::Index::SegReader>. + * accessed via [SegReader](clownfish:class:lucy: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 [Folder](clownfish:class:lucy: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 [IndexManager](clownfish:class:lucy: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/4a6f325a/core/Lucy/Index/Posting.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/Posting.cfh b/core/Lucy/Index/Posting.cfh index 0adb476..0f5fe82 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 + * [MatchPosting](clownfish:class:lucy:MatchPosting), the simplest * posting format, and - * L<ScorePosting|Lucy::Index::Posting::ScorePosting>, the default. + * [ScorePosting](clownfish:class:lucy:ScorePosting), the default. */ class Lucy::Index::Posting nickname Post inherits Lucy::Util::Stepper { http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Index/Posting/RichPosting.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/Posting/RichPosting.cfh b/core/Lucy/Index/Posting/RichPosting.cfh index df75449..3badbf5 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 + * [ScorePosting](clownfish:class:lucy: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. + * [Analyzer](clownfish:class:lucy:Analyzer) which assigns varying boosts to + * individual [Token](clownfish:class:lucy: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/4a6f325a/core/Lucy/Index/PostingListReader.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/PostingListReader.cfh b/core/Lucy/Index/PostingListReader.cfh index a961fc9..28d6921 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 [PostingList](clownfish:class:lucy:PostingList) * objects which convey document matching information. */ public class Lucy::Index::PostingListReader nickname PListReader http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Index/SegReader.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/SegReader.cfh b/core/Lucy/Index/SegReader.cfh index e34977e..6582190 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 [Architecture](clownfish:class:lucy:Architecture)'s * factory methods. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Index/SegWriter.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/SegWriter.cfh b/core/Lucy/Index/SegWriter.cfh index a7bad7e..5825970 100644 --- a/core/Lucy/Index/SegWriter.cfh +++ b/core/Lucy/Index/SegWriter.cfh @@ -20,13 +20,13 @@ 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 [Segment](clownfish:class:lucy:Segment) and Inverter, invokes the + * [Analyzer](clownfish:class:lucy:Analyzer) chain, and feeds low + * level [DataWriters](clownfish:class:lucy:DataWriter) such as * PostingListWriter and DocWriter. * * The sub-components of a SegWriter are determined by - * L<Architecture|Lucy::Plan::Architecture>. DataWriter components + * [Architecture](clownfish:class:lucy: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(). http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Index/Snapshot.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/Snapshot.cfh b/core/Lucy/Index/Snapshot.cfh index c7d69b7..2c744a0 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 + * [IndexReader](clownfish:class:lucy:IndexReader) objects interpret the data * associated with a single Snapshot. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Plan/Architecture.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Plan/Architecture.cfh b/core/Lucy/Plan/Architecture.cfh index d35f5bf..b04b0e3 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>. + * [SegWriter](clownfish:class:lucy:SegWriter) and + * [SegReader](clownfish:class:lucy:SegReader). */ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj { http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Plan/FieldType.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Plan/FieldType.cfh b/core/Lucy/Plan/FieldType.cfh index 3124493..215bc7d 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 + * [Similarity](clownfish:class:lucy:Similarity) object which defines matching * and scoring behavior for the field. It is required if the field is * `indexed`. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Plan/FullTextType.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Plan/FullTextType.cfh b/core/Lucy/Plan/FullTextType.cfh index d94c69d..6537b8b 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". + * [FieldType](clownfish:class:lucy:FieldType) tuned for "full text search". * * Full text fields are associated with an - * L<Analyzer|Lucy::Analysis::Analyzer>, which is used to tokenize and + * [Analyzer](clownfish:class:lucy: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>. + * [StringType](clownfish:class:lucy: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 + * [Highlighter](clownfish:class:lucy:Highlighter) for excerpt selection and search * term highlighting. */ public void http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Search/ANDQuery.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/ANDQuery.cfh b/core/Lucy/Search/ANDQuery.cfh index 0c2e94a..200fc75 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 [Query](clownfish:class:lucy: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/4a6f325a/core/Lucy/Search/Collector.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/Collector.cfh b/core/Lucy/Search/Collector.cfh index 0dd8cc3..4d71e13 100644 --- a/core/Lucy/Search/Collector.cfh +++ b/core/Lucy/Search/Collector.cfh @@ -19,7 +19,7 @@ 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 + * [Matcher](clownfish:class:lucy:Matcher) iterates through, based on how the * abstract Collect() method is implemented. * * Collectors operate on individual segments, but must operate within the @@ -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 + * [BitVector](clownfish:class:lucy: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/4a6f325a/core/Lucy/Search/Compiler.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/Compiler.cfh b/core/Lucy/Search/Compiler.cfh index 4f490cf..5335fb2 100644 --- a/core/Lucy/Search/Compiler.cfh +++ b/core/Lucy/Search/Compiler.cfh @@ -19,8 +19,8 @@ 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 [Query](clownfish:class:lucy:Query) object and compile a + * [Matcher](clownfish:class:lucy: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() @@ -36,7 +36,7 @@ parcel Lucy; * 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 [Searcher](clownfish:class:lucy: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 @@ -46,7 +46,7 @@ parcel Lucy; * 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 Compiler meets a [SegReader](clownfish:class:lucy: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 http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Search/IndexSearcher.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/IndexSearcher.cfh b/core/Lucy/Search/IndexSearcher.cfh index 2495c45..7a7cd26 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>). + * [PolySearcher](clownfish:class:lucy:PolySearcher)). * * IndexSearchers operate against a single point-in-time view or - * L<Snapshot|Lucy::Index::Snapshot> of the index. If an index is + * [Snapshot](clownfish:class:lucy: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/4a6f325a/core/Lucy/Search/LeafQuery.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/LeafQuery.cfh b/core/Lucy/Search/LeafQuery.cfh index b4d07f1..600e51b 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. + * [QueryParser](clownfish:class:lucy:QueryParser)'s 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 + * [TermQuery](clownfish:class:lucy:TermQuery) or + * [PhraseQuery](clownfish:class:lucy: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/4a6f325a/core/Lucy/Search/NOTQuery.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/NOTQuery.cfh b/core/Lucy/Search/NOTQuery.cfh index a9f10ad..b0f72dc 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 [Query](clownfish:class:lucy: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" + * [ANDQuery](clownfish:class:lucy:ANDQuery) to provide "a AND NOT b" * semantics. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Search/NoMatchQuery.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/NoMatchQuery.cfh b/core/Lucy/Search/NoMatchQuery.cfh index 13a5bc5..5dc0b02 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 + * [QueryParser](clownfish:class:lucy: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/4a6f325a/core/Lucy/Search/ORQuery.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/ORQuery.cfh b/core/Lucy/Search/ORQuery.cfh index 8fc5eb8..20c5c3b 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 [Query](clownfish:class:lucy: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/4a6f325a/core/Lucy/Search/PhraseQuery.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/PhraseQuery.cfh b/core/Lucy/Search/PhraseQuery.cfh index 0f78399..8a6a461 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 [Query](clownfish:class:lucy:Query) for matching * against an ordered sequence of terms. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Search/PolyQuery.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/PolyQuery.cfh b/core/Lucy/Search/PolyQuery.cfh index 25c465b..5d47534 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 + * [ANDQuery](clownfish:class:lucy:ANDQuery), + * [ORQuery](clownfish:class:lucy:ORQuery), + * [NOTQuery](clownfish:class:lucy:NOTQuery), and + * [RequiredOptionalQuery](clownfish:class:lucy: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/4a6f325a/core/Lucy/Search/Query.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/Query.cfh b/core/Lucy/Search/Query.cfh index 2774ee6..d51398b 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> + * such as 'foo AND bar' to a [QueryParser's](clownfish:class:lucy: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 + * Query subclasses such as [ANDQuery](clownfish:class:lucy:ANDQuery) and + * [TermQuery](clownfish:class:lucy: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 + * in compiling a Query down to a [Matcher](clownfish:class:lucy:Matcher) which * can actually match and score documents. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Search/QueryParser.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/QueryParser.cfh b/core/Lucy/Search/QueryParser.cfh index d8ef52f..9b26736 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. + * [Query](clownfish:class:lucy:Query) objects, suitable for feeding into + * [IndexSearcher](clownfish:class:lucy:IndexSearcher) and other + * [Searcher](clownfish:class:lucy:Searcher) subclasses. * * The following syntactical constructs are recognized by QueryParser: * @@ -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 [Schema](clownfish:class:lucy:Schema). + * @param analyzer An [Analyzer](clownfish:class:lucy: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 http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Search/Searcher.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/Searcher.cfh b/core/Lucy/Search/Searcher.cfh index c61ade3..c491c36 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>. + * [IndexSearcher](clownfish:class:lucy:IndexSearcher) and + * [PolySearcher](clownfish:class:lucy: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 [SortSpec](clownfish:class:lucy: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>. + * [Collector](clownfish:class:lucy:Collector). * * @param query A Query. * @param collector A Collector. http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Search/SortRule.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/SortRule.cfh b/core/Lucy/Search/SortRule.cfh index 7a009c2..2b9eb70 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](clownfish:class:lucy: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/4a6f325a/core/Lucy/Search/SortSpec.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/SortSpec.cfh b/core/Lucy/Search/SortSpec.cfh index 0c59909..954c4f0 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](clownfish:class:lucy:SortRule). * * Fields you wish to sort against must be `sortable`. * http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Search/TermQuery.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/TermQuery.cfh b/core/Lucy/Search/TermQuery.cfh index 16d717f..0558387 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 [Query](clownfish:class:lucy:Query) for matching * individual terms in a specific field. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Store/FSFolder.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/FSFolder.cfh b/core/Lucy/Store/FSFolder.cfh index 7d87745..337c38f 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 [Folder](clownfish:class:lucy:Folder) using a single file system * directory and multiple files. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Store/Folder.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/Folder.cfh b/core/Lucy/Store/Folder.cfh index a275e14..cbf2c65 100644 --- a/core/Lucy/Store/Folder.cfh +++ b/core/Lucy/Store/Folder.cfh @@ -23,7 +23,7 @@ parcel Lucy; * a key-value pair from a hash, or something else. * * The archetypal implementation of Folder, - * L<FSFolder|Lucy::Store::FSFolder>, represents a directory on + * [FSFolder](clownfish:class:lucy: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/4a6f325a/core/Lucy/Store/Lock.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/Lock.cfh b/core/Lucy/Store/Lock.cfh index dcd5fd9..1e20aaa 100644 --- a/core/Lucy/Store/Lock.cfh +++ b/core/Lucy/Store/Lock.cfh @@ -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](clownfish:class: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/4a6f325a/core/Lucy/Store/LockFactory.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/LockFactory.cfh b/core/Lucy/Store/LockFactory.cfh index 5cf8232..3204d92 100644 --- a/core/Lucy/Store/LockFactory.cfh +++ b/core/Lucy/Store/LockFactory.cfh @@ -34,7 +34,7 @@ public class Lucy::Store::LockFactory nickname LockFact new(Folder *folder, String *host); /** - * @param folder A L<Lucy::Store::Folder>. + * @param folder A [Folder](clownfish:class:lucy:Folder). * @param host An identifier which should be unique per-machine. */ public inert LockFactory* http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/Lucy/Store/RAMFolder.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/RAMFolder.cfh b/core/Lucy/Store/RAMFolder.cfh index c04267d..5d2b562 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. + * [Folder](clownfish:class:lucy: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/4a6f325a/core/Lucy/Store/SharedLock.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/SharedLock.cfh b/core/Lucy/Store/SharedLock.cfh index e409e79..3ad6fb9 100644 --- a/core/Lucy/Store/SharedLock.cfh +++ b/core/Lucy/Store/SharedLock.cfh @@ -19,7 +19,7 @@ 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 + * [Lock](clownfish:class:lucy:Lock), taking the same constructor arguments and * implementing the same list of methods. It differs from Lock only in the * semantics of two methods. * http://git-wip-us.apache.org/repos/asf/lucy/blob/4a6f325a/core/LucyX/Search/ProximityQuery.cfh ---------------------------------------------------------------------- diff --git a/core/LucyX/Search/ProximityQuery.cfh b/core/LucyX/Search/ProximityQuery.cfh index 904cd6a..635873d 100644 --- a/core/LucyX/Search/ProximityQuery.cfh +++ b/core/LucyX/Search/ProximityQuery.cfh @@ -18,7 +18,7 @@ parcel Lucy; /** Query matching an ordered list of terms. * - * ProximityQuery is a subclass of L<Lucy::Search::Query> for matching + * ProximityQuery is a subclass of [Query](clownfish:class:lucy:Query) for matching * against an ordered sequence of terms. */
