Add clownfish URIs for methods
Project: http://git-wip-us.apache.org/repos/asf/lucy/repo Commit: http://git-wip-us.apache.org/repos/asf/lucy/commit/82d38667 Tree: http://git-wip-us.apache.org/repos/asf/lucy/tree/82d38667 Diff: http://git-wip-us.apache.org/repos/asf/lucy/diff/82d38667 Branch: refs/heads/markdown Commit: 82d38667a204f4b0dc0f69151f3e54d59f1ec2dc Parents: 60f2df8 Author: Nick Wellnhofer <[email protected]> Authored: Tue Dec 2 18:17:41 2014 +0100 Committer: Nick Wellnhofer <[email protected]> Committed: Tue Dec 2 18:46:09 2014 +0100 ---------------------------------------------------------------------- core/Lucy/Analysis/Analyzer.cfh | 2 +- core/Lucy/Docs/FileLocking.cfh | 6 +++--- core/Lucy/Highlight/Highlighter.cfh | 4 ++-- core/Lucy/Index/BackgroundMerger.cfh | 8 +++---- core/Lucy/Index/DataWriter.cfh | 2 +- core/Lucy/Index/IndexReader.cfh | 2 +- core/Lucy/Index/Indexer.cfh | 24 ++++++++++----------- core/Lucy/Index/Inverter.cfh | 6 +++--- core/Lucy/Index/Lexicon.cfh | 2 +- core/Lucy/Index/PolyReader.cfh | 2 +- core/Lucy/Index/PostingList.cfh | 2 +- core/Lucy/Index/PostingListReader.cfh | 2 +- core/Lucy/Index/SegPostingList.cfh | 2 +- core/Lucy/Index/SegWriter.cfh | 12 +++++------ core/Lucy/Index/Snapshot.cfh | 2 +- core/Lucy/Plan/Architecture.cfh | 26 +++++++++++------------ core/Lucy/Plan/FieldType.cfh | 2 +- core/Lucy/Plan/Schema.cfh | 2 +- core/Lucy/Search/Collector.cfh | 8 +++---- core/Lucy/Search/Collector/SortCollector.cfh | 2 +- core/Lucy/Search/Compiler.cfh | 18 ++++++++-------- core/Lucy/Search/LeafQuery.cfh | 2 +- core/Lucy/Search/Matcher.cfh | 8 +++---- core/Lucy/Search/ORMatcher.cfh | 2 +- core/Lucy/Search/Query.cfh | 6 +++--- core/Lucy/Search/QueryParser.cfh | 20 ++++++++--------- core/Lucy/Store/DirHandle.cfh | 4 ++-- core/Lucy/Store/FileHandle.cfh | 2 +- core/Lucy/Store/Folder.cfh | 2 +- core/Lucy/Store/InStream.cfh | 4 ++-- core/Lucy/Store/Lock.cfh | 12 +++++------ core/Lucy/Store/LockFactory.cfh | 10 ++++----- core/Lucy/Store/SharedLock.cfh | 10 ++++----- 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 +- 41 files changed, 126 insertions(+), 126 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Analysis/Analyzer.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Analysis/Analyzer.cfh b/core/Lucy/Analysis/Analyzer.cfh index bbc9722..a9b868d 100644 --- a/core/Lucy/Analysis/Analyzer.cfh +++ b/core/Lucy/Analysis/Analyzer.cfh @@ -38,7 +38,7 @@ public abstract class Lucy::Analysis::Analyzer inherits Clownfish::Obj { /** Kick off an analysis chain, creating an Inversion from string input. * The default implementation simply creates an initial Inversion with a - * single Token, then calls Transform(), but occasionally subclasses will + * single Token, then calls [Transform()](clownfish:method: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/82d38667/core/Lucy/Docs/FileLocking.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Docs/FileLocking.cfh b/core/Lucy/Docs/FileLocking.cfh index 0192c71..5536477 100644 --- a/core/Lucy/Docs/FileLocking.cfh +++ b/core/Lucy/Docs/FileLocking.cfh @@ -39,7 +39,7 @@ parcel Lucy; * complex. * * Once an index file is no longer listed in the most recent snapshot, Indexer - * attempts to delete it as part of a post-Commit() cleanup routine. It is + * attempts to delete it as part of a post-[Commit()](clownfish:method:Indexer:Commit) cleanup routine. It is * possible that at the moment an Indexer is deleting files which it believes * no longer needed, a Searcher referencing an earlier snapshot is in fact * using them. The more often that an index is either updated or searched, @@ -61,9 +61,9 @@ parcel Lucy; * * Under normal circumstances, it is neither necessary nor desirable for * IndexReaders to secure read locks against an index, but for NFS we have to - * make an exception. LockFactory's Make_Shared_Lock() method exists for this + * make an exception. LockFactory's [Make_Shared_Lock()](clownfish:method:LockFactory:Make_Shared_Lock) method exists for this * reason; supplying an IndexManager instance to IndexReader's constructor - * activates an internal locking mechanism using Make_Shared_Lock() which + * activates an internal locking mechanism using [Make_Shared_Lock()](clownfish:method: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/82d38667/core/Lucy/Highlight/Highlighter.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Highlight/Highlighter.cfh b/core/Lucy/Highlight/Highlighter.cfh index 15b41ae..fef2656 100644 --- a/core/Lucy/Highlight/Highlighter.cfh +++ b/core/Lucy/Highlight/Highlighter.cfh @@ -59,7 +59,7 @@ public class Lucy::Highlight::Highlighter inherits Clownfish::Obj { Create_Excerpt(Highlighter *self, HitDoc *hit_doc); /** Encode text with HTML entities. This method is called internally by - * Create_Excerpt() for each text fragment when assembling an excerpt. A + * [Create_Excerpt()](clownfish:method:Create_Excerpt) for each text fragment when assembling an excerpt. A * subclass can override this if the text should be encoded differently or * not at all. */ @@ -67,7 +67,7 @@ public class Lucy::Highlight::Highlighter inherits Clownfish::Obj { Encode(Highlighter *self, String *text); /** Highlight a small section of text. By default, prepends pre-tag and - * appends post-tag. This method is called internally by Create_Excerpt() + * appends post-tag. This method is called internally by [Create_Excerpt()](clownfish:method:Create_Excerpt) * when assembling an excerpt. */ public incremented String* http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/BackgroundMerger.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/BackgroundMerger.cfh b/core/Lucy/Index/BackgroundMerger.cfh index 4e1def8..b281f37 100644 --- a/core/Lucy/Index/BackgroundMerger.cfh +++ b/core/Lucy/Index/BackgroundMerger.cfh @@ -68,16 +68,16 @@ public class Lucy::Index::BackgroundMerger nickname BGMerger /** Commit any changes made to the index. Until this is called, none of * the changes made during an indexing session are permanent. * - * Calls Prepare_Commit() implicitly if it has not already been called. + * Calls [Prepare_Commit()](clownfish:method:Prepare_Commit) implicitly if it has not already been called. */ public void Commit(BackgroundMerger *self); - /** Perform the expensive setup for Commit() in advance, so that Commit() + /** Perform the expensive setup for [Commit()](clownfish:method:Commit) in advance, so that [Commit()](clownfish:method:Commit) * completes quickly. * - * Towards the end of Prepare_Commit(), the BackgroundMerger attempts to - * re-acquire the write lock, which is then held until Commit() finishes + * Towards the end of [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 * and releases it. */ public void http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/DataWriter.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/DataWriter.cfh b/core/Lucy/Index/DataWriter.cfh index 2e7586f..26e6033 100644 --- a/core/Lucy/Index/DataWriter.cfh +++ b/core/Lucy/Index/DataWriter.cfh @@ -83,7 +83,7 @@ public class Lucy::Index::DataWriter inherits Clownfish::Obj { /** Move content from an existing segment into the one currently being * written. * - * The default implementation calls Add_Segment() then Delete_Segment(). + * The default implementation calls [Add_Segment()](clownfish:method:Add_Segment) then [Delete_Segment()](clownfish:method: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/82d38667/core/Lucy/Index/IndexReader.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/IndexReader.cfh b/core/Lucy/Index/IndexReader.cfh index aa08e2b..10e7957 100644 --- a/core/Lucy/Index/IndexReader.cfh +++ b/core/Lucy/Index/IndexReader.cfh @@ -29,7 +29,7 @@ parcel Lucy; * * IndexReaders are composites; most of the work is done by individual * [DataReader](clownfish:class:DataReader) sub-components, which may be - * accessed via Fetch() and Obtain(). The most efficient and powerful access + * accessed via [Fetch()](clownfish:method:Fetch) and [Obtain()](clownfish:method:Obtain). The most efficient and powerful access * to index data happens at the segment level via * [SegReader](clownfish:class:SegReader)'s sub-components. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/Indexer.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/Indexer.cfh b/core/Lucy/Index/Indexer.cfh index 98eec00..4ac2441 100644 --- a/core/Lucy/Index/Indexer.cfh +++ b/core/Lucy/Index/Indexer.cfh @@ -31,7 +31,7 @@ parcel Lucy; * `host` id to Indexer's constructor or index corruption will * occur. See L<Lucy::Docs::FileLocking> for a detailed discussion. * - * Note: at present, Delete_By_Term() and Delete_By_Query() only affect + * Note: at present, [Delete_By_Term()](clownfish:method:Delete_By_Term) and [Delete_By_Query()](clownfish:method:Delete_By_Query) only affect * documents which had been previously committed to the index -- and not any * documents added this indexing session but not yet committed. This may * change in a future update. @@ -94,7 +94,7 @@ public class Lucy::Index::Indexer inherits Clownfish::Obj { /** Mark documents which contain the supplied term as deleted, so that * they will be excluded from search results and eventually removed * altogether. The change is not apparent to search apps until after - * Commit() succeeds. + * [Commit()](clownfish:method:Commit) succeeds. * * @param field The name of an indexed field. (If it is not spec'd as * `indexed`, an error will occur.) @@ -123,20 +123,20 @@ public class Lucy::Index::Indexer inherits Clownfish::Obj { * while, as it can involve rewriting large amounts of data. * * Every Indexer session which changes index content and ends in a - * Commit() creates a new segment. Once written, segments are never + * [Commit()](clownfish:method:Commit) creates a new segment. Once written, segments are never * modified. However, they are periodically recycled by feeding their * content into the segment currently being written. * - * The Optimize() method causes all existing index content to be fed back - * into the Indexer. When Commit() completes after an Optimize(), the - * index will consist of one segment. So Optimize() must be called - * before Commit(). Also, optimizing a fresh index created from scratch + * The [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 * has no effect. * * Historically, there was a significant search-time performance benefit * to collapsing down to a single segment versus even two segments. Now * the effect of collapsing is much less significant, and calling - * Optimize() is rarely justified. + * [Optimize()](clownfish:method:Optimize) is rarely justified. */ public void Optimize(Indexer *self); @@ -144,15 +144,15 @@ public class Lucy::Index::Indexer inherits Clownfish::Obj { /** Commit any changes made to the index. Until this is called, none of * the changes made during an indexing session are permanent. * - * Calling Commit() invalidates the Indexer, so if you want to make more + * Calling [Commit()](clownfish:method:Commit) invalidates the Indexer, so if you want to make more * changes you'll need a new one. */ public void Commit(Indexer *self); - /** Perform the expensive setup for Commit() in advance, so that Commit() - * completes quickly. (If Prepare_Commit() is not called explicitly by - * the user, Commit() will call it internally.) + /** Perform the expensive setup for [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.) */ public void Prepare_Commit(Indexer *self); http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/Inverter.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/Inverter.cfh b/core/Lucy/Index/Inverter.cfh index 7858a0a..f635443 100644 --- a/core/Lucy/Index/Inverter.cfh +++ b/core/Lucy/Index/Inverter.cfh @@ -42,13 +42,13 @@ class Lucy::Index::Inverter inherits Clownfish::Obj { inert Inverter* init(Inverter *self, Schema *schema, Segment *segment); - /** Invert the document, first calling Set_Doc(), then Add_Field() for + /** Invert the document, first calling [Set_Doc()](clownfish:method:Set_Doc), then [Add_Field()](clownfish:method:Add_Field) for * each field in the Doc. */ public void Invert_Doc(Inverter *self, Doc *doc); - /** Set the object's `doc` member. Calls Clear() as side + /** Set the object's `doc` member. Calls [Clear()](clownfish:method:Clear) as side * effect. */ public void @@ -63,7 +63,7 @@ class Lucy::Index::Inverter inherits Clownfish::Obj { * it. * * The InverterEntry's value should have already been set to the field's - * value when Add_Field() is called. + * value when [Add_Field()](clownfish:method:Add_Field) is called. */ void Add_Field(Inverter *self, InverterEntry *entry); http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/Lexicon.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/Lexicon.cfh b/core/Lucy/Index/Lexicon.cfh index 16058c1..e14d71f 100644 --- a/core/Lucy/Index/Lexicon.cfh +++ b/core/Lucy/Index/Lexicon.cfh @@ -55,7 +55,7 @@ public class Lucy::Index::Lexicon nickname Lex inherits Clownfish::Obj { public abstract bool Next(Lexicon *self); - /** Reset the iterator. Next() must be called to proceed to the first + /** Reset the iterator. [Next()](clownfish:method:Next) must be called to proceed to the first * element. */ public abstract void http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/PolyReader.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/PolyReader.cfh b/core/Lucy/Index/PolyReader.cfh index 5eda742..8418640 100644 --- a/core/Lucy/Index/PolyReader.cfh +++ b/core/Lucy/Index/PolyReader.cfh @@ -20,7 +20,7 @@ parcel Lucy; * * PolyReader conflates index data from multiple segments. For instance, if * an index contains three segments with 10 documents each, PolyReader's - * Doc_Max() method will return 30. + * [Doc_Max()](clownfish:method:Doc_Max) method will return 30. * * Some of PolyReader's [DataReader](clownfish:class:DataReader) components * may be less efficient or complete than the single-segment implementations http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/PostingList.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/PostingList.cfh b/core/Lucy/Index/PostingList.cfh index 702db7c..3bd7352 100644 --- a/core/Lucy/Index/PostingList.cfh +++ b/core/Lucy/Index/PostingList.cfh @@ -54,7 +54,7 @@ public class Lucy::Index::PostingList nickname PList abstract void Seek_Lex(PostingList *self, Lexicon *lexicon); - /** Invoke Post_Make_Matcher() for this PostingList's posting. + /** Invoke [Post_Make_Matcher()](clownfish:method: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/82d38667/core/Lucy/Index/PostingListReader.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/PostingListReader.cfh b/core/Lucy/Index/PostingListReader.cfh index 6474aeb..b2ab868 100644 --- a/core/Lucy/Index/PostingListReader.cfh +++ b/core/Lucy/Index/PostingListReader.cfh @@ -34,7 +34,7 @@ public class Lucy::Index::PostingListReader nickname PListReader * * @param field A field name. * @param term If supplied, the PostingList will be pre-located to this - * term using Seek(). + * term using [Seek()](clownfish:method:PostingList:Seek). */ public abstract incremented nullable PostingList* Posting_List(PostingListReader *self, String *field = NULL, http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/SegPostingList.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/SegPostingList.cfh b/core/Lucy/Index/SegPostingList.cfh index bf2cc3f..9a81c30 100644 --- a/core/Lucy/Index/SegPostingList.cfh +++ b/core/Lucy/Index/SegPostingList.cfh @@ -69,7 +69,7 @@ class Lucy::Index::SegPostingList nickname SegPList public void Seek(SegPostingList *self, Obj *target = NULL); - /** Optimized version of Seek(), designed to speed sequential access. + /** Optimized version of [Seek()](clownfish:method:Seek), designed to speed sequential access. */ void Seek_Lex(SegPostingList *self, Lexicon *lexicon); http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/SegWriter.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/SegWriter.cfh b/core/Lucy/Index/SegWriter.cfh index 16f784b..07d96d7 100644 --- a/core/Lucy/Index/SegWriter.cfh +++ b/core/Lucy/Index/SegWriter.cfh @@ -27,9 +27,9 @@ parcel Lucy; * * 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() have - * Add_Inverted_Doc() invoked for each document supplied to SegWriter's - * Add_Doc(). + * 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). */ public class Lucy::Index::SegWriter inherits Lucy::Index::DataWriter { @@ -57,8 +57,8 @@ public class Lucy::Index::SegWriter inherits Lucy::Index::DataWriter { /** * Register a DataWriter component with the SegWriter. (Note that - * registration simply makes the writer available via Fetch(), so you may - * also want to call Add_Writer()). + * registration simply makes the writer available via [Fetch()](clownfish:method:Fetch), so you may + * also want to call [Add_Writer()](clownfish:method:Add_Writer)). * * @param api The name of the DataWriter api which `writer` * implements. @@ -89,7 +89,7 @@ public class Lucy::Index::SegWriter inherits Lucy::Index::DataWriter { Prep_Seg_Dir(SegWriter *self); /** Add a document to the segment. Inverts `doc`, increments - * the Segment's internal document id, then calls Add_Inverted_Doc(), + * the Segment's internal document id, then calls [Add_Inverted_Doc()](clownfish:method:Add_Inverted_Doc), * feeding all sub-writers. */ public void http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Index/Snapshot.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Index/Snapshot.cfh b/core/Lucy/Index/Snapshot.cfh index 634be2c..f0c1bd9 100644 --- a/core/Lucy/Index/Snapshot.cfh +++ b/core/Lucy/Index/Snapshot.cfh @@ -95,7 +95,7 @@ public class Lucy::Index::Snapshot inherits Clownfish::Obj { Set_Path(Snapshot *self, String *path); /** Get the path to the snapshot file. Initially NULL; updated by - * Read_File(), Write_File(), and Set_Path(). + * [Read_File()](clownfish:method:Read_File), [Write_File()](clownfish:method:Write_File), and [Set_Path()](clownfish:method:Set_Path). */ public nullable String* Get_Path(Snapshot *self); http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Plan/Architecture.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Plan/Architecture.cfh b/core/Lucy/Plan/Architecture.cfh index 3162daa..34cefb8 100644 --- a/core/Lucy/Plan/Architecture.cfh +++ b/core/Lucy/Plan/Architecture.cfh @@ -42,7 +42,7 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj { public void Init_Seg_Writer(Architecture *self, SegWriter *writer); - /** Spawn a LexiconWriter and Register() it with the supplied SegWriter, + /** Spawn a LexiconWriter and [Register()](clownfish:method:SegWriter:Register) it with the supplied SegWriter, * but don't add it to the SegWriter's writer stack. * * @param writer A SegWriter. @@ -50,7 +50,7 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj { public void Register_Lexicon_Writer(Architecture *self, SegWriter *writer); - /** Spawn a PostingListWriter and Register() it with the supplied + /** Spawn a PostingListWriter and [Register()](clownfish:method:SegWriter:Register) it with the supplied * SegWriter, adding it to the SegWriter's writer stack. The SegWriter * must contain a previously registered LexiconWriter. * @@ -59,7 +59,7 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj { public void Register_Posting_List_Writer(Architecture *self, SegWriter *writer); - /** Spawn a DataWriter and Register() it with the supplied SegWriter, + /** Spawn a DataWriter and [Register()](clownfish:method:SegWriter:Register) it with the supplied SegWriter, * adding it to the SegWriter's writer stack. * * @param writer A SegWriter. @@ -67,7 +67,7 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj { public void Register_Doc_Writer(Architecture *self, SegWriter *writer); - /** Spawn a SortWriter and Register() it with the supplied SegWriter, + /** Spawn a SortWriter and [Register()](clownfish:method:SegWriter:Register) it with the supplied SegWriter, * adding it to the SegWriter's writer stack. * * @param writer A SegWriter. @@ -75,7 +75,7 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj { public void Register_Sort_Writer(Architecture *self, SegWriter *writer); - /** Spawn a HighlightWriter and Register() it with the supplied SegWriter, + /** Spawn a HighlightWriter and [Register()](clownfish:method:SegWriter:Register) it with the supplied SegWriter, * adding it to the SegWriter's writer stack. * * @param writer A SegWriter. @@ -83,8 +83,8 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj { public void Register_Highlight_Writer(Architecture *self, SegWriter *writer); - /** Spawn a DeletionsWriter and Register() it with the supplied SegWriter, - * also calling Set_Del_Writer(). + /** Spawn a DeletionsWriter and [Register()](clownfish:method:SegWriter:Register) it with the supplied SegWriter, + * also calling [Set_Del_Writer()](clownfish:method:SegWriter:Set_Del_Writer). * * @param writer A SegWriter. */ @@ -96,28 +96,28 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj { public void Init_Seg_Reader(Architecture *self, SegReader *reader); - /** Spawn a DocReader and Register() it with the supplied SegReader. + /** Spawn a DocReader and [Register()](clownfish:method:SegReader:Register) it with the supplied SegReader. * * @param reader A SegReader. */ public void Register_Doc_Reader(Architecture *self, SegReader *reader); - /** Spawn a PostingListReader and Register() it with the supplied SegReader. + /** Spawn a PostingListReader and [Register()](clownfish:method:SegReader:Register) it with the supplied SegReader. * * @param reader A SegReader. */ public void Register_Posting_List_Reader(Architecture *self, SegReader *reader); - /** Spawn a SortReader and Register() it with the supplied SegReader. + /** Spawn a SortReader and [Register()](clownfish:method:SegReader:Register) it with the supplied SegReader. * * @param reader A SegReader. */ public void Register_Sort_Reader(Architecture *self, SegReader *reader); - /** Spawn a HighlightReader and Register() it with the supplied + /** Spawn a HighlightReader and [Register()](clownfish:method:SegReader:Register) it with the supplied * SegReader. * * @param reader A SegReader. @@ -125,14 +125,14 @@ public class Lucy::Plan::Architecture nickname Arch inherits Clownfish::Obj { public void Register_Highlight_Reader(Architecture *self, SegReader *reader); - /** Spawn a LexiconReader and Register() it with the supplied SegReader. + /** Spawn a LexiconReader and [Register()](clownfish:method:SegReader:Register) it with the supplied SegReader. * * @param reader A SegReader. */ public void Register_Lexicon_Reader(Architecture *self, SegReader *reader); - /** Spawn a DeletionsReader and Register() it with the supplied SegReader. + /** Spawn a DeletionsReader and [Register()](clownfish:method:SegReader:Register) it with the supplied SegReader. * * @param reader A SegReader. */ http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Plan/FieldType.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Plan/FieldType.cfh b/core/Lucy/Plan/FieldType.cfh index 1c0880e..7da470b 100644 --- a/core/Lucy/Plan/FieldType.cfh +++ b/core/Lucy/Plan/FieldType.cfh @@ -130,7 +130,7 @@ public abstract class Lucy::Plan::FieldType nickname FType Binary(FieldType *self); /** Compare two values for the field. The default implementation - * dispatches to the Compare_To() method of argument `a`. + * dispatches to the [Compare_To()](clownfish:method: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/82d38667/core/Lucy/Plan/Schema.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Plan/Schema.cfh b/core/Lucy/Plan/Schema.cfh index 6d00eac..017ac7f 100644 --- a/core/Lucy/Plan/Schema.cfh +++ b/core/Lucy/Plan/Schema.cfh @@ -51,7 +51,7 @@ public class Lucy::Plan::Schema inherits Clownfish::Obj { * * If this method has already been called for the supplied * `field`, it will merely test to verify that the supplied - * FieldType Equals() the existing one. + * FieldType [Equals()](clownfish:method: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/82d38667/core/Lucy/Search/Collector.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/Collector.cfh b/core/Lucy/Search/Collector.cfh index b15f2e0..b260bd3 100644 --- a/core/Lucy/Search/Collector.cfh +++ b/core/Lucy/Search/Collector.cfh @@ -20,11 +20,11 @@ parcel Lucy; * * A Collector decides what to do with the hits that a * [Matcher](clownfish:class:Matcher) iterates through, based on how the - * abstract Collect() method is implemented. + * abstract [Collect()](clownfish:method:Collect) method is implemented. * * Collectors operate on individual segments, but must operate within the * context of a larger collection. Each time the collector moves to a new - * segment, Set_Reader(), Set_Base() and Set_Matcher() will be called, and the + * segment, [Set_Reader()](clownfish:method:Set_Reader), [Set_Base()](clownfish:method:Set_Base) and [Set_Matcher()](clownfish:method:Set_Matcher) will be called, and the * collector must take the updated information into account. */ @@ -57,13 +57,13 @@ public abstract class Lucy::Search::Collector nickname Coll Set_Reader(Collector *self, SegReader *reader); /** Set the "base" document id, an offset which must be added to the - * `doc_id` supplied via Collect() to get the doc id for the + * `doc_id` supplied via [Collect()](clownfish:method:Collect) to get the doc id for the * larger index. */ public void Set_Base(Collector *self, int32_t base); - /** Indicate whether the Collector will call Score() on its Matcher. + /** Indicate whether the Collector will call [Score()](clownfish:method:Matcher:Score) on its Matcher. */ public abstract bool Need_Score(Collector *self); http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Search/Collector/SortCollector.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/Collector/SortCollector.cfh b/core/Lucy/Search/Collector/SortCollector.cfh index 2df7bb4..88757d0 100644 --- a/core/Lucy/Search/Collector/SortCollector.cfh +++ b/core/Lucy/Search/Collector/SortCollector.cfh @@ -66,7 +66,7 @@ class Lucy::Search::Collector::SortCollector nickname SortColl Pop_Match_Docs(SortCollector *self); /** Accessor for "total_hits" member, which tracks the number of times - * that Collect() was called. + * that [Collect()](clownfish:method:Collect) was called. */ uint32_t Get_Total_Hits(SortCollector *self); http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Search/Compiler.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/Compiler.cfh b/core/Lucy/Search/Compiler.cfh index eb260af..cab0286 100644 --- a/core/Lucy/Search/Compiler.cfh +++ b/core/Lucy/Search/Compiler.cfh @@ -23,15 +23,15 @@ parcel Lucy; * [Matcher](clownfish:class:Matcher) object that can do real work. * * The simplest Compiler subclasses -- such as those associated with - * constant-scoring Query types -- might simply implement a Make_Matcher() + * constant-scoring Query types -- might simply implement a [Make_Matcher()](clownfish:method:Make_Matcher) * method which passes along information verbatim from the Query to the * Matcher's constructor. * * However it is common for the Compiler to perform some calculations which * affect it's "weight" -- a floating point multiplier that the Matcher will * factor into each document's score. If that is the case, then the Compiler - * subclass may wish to override Get_Weight(), Sum_Of_Squared_Weights(), and - * Apply_Norm_Factor(). + * subclass may wish to override [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). * * Compiling a Matcher is a two stage process. * @@ -45,7 +45,7 @@ parcel Lucy; * TF/IDF weighting algorithm to adjust the Compiler's weight; custom * subclasses might do something similar. * - * The second stage of compilation is Make_Matcher(), method, which is where + * The second stage of compilation is [Make_Matcher()](clownfish:method:Make_Matcher), method, which is where * the Compiler meets a [SegReader](clownfish:class: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 @@ -54,7 +54,7 @@ parcel Lucy; * use new information supplied by the SegReader -- such as whether a term is * missing from the local index even though it is present within the larger * collection represented by the Searcher -- when figuring out what to feed to - * the Matchers's constructor, or whether Make_Matcher() should return a + * the Matchers's constructor, or whether [Make_Matcher()](clownfish:method:Make_Matcher) should return a * Matcher at all. */ public class Lucy::Search::Compiler inherits Lucy::Search::Query { @@ -78,7 +78,7 @@ public class Lucy::Search::Compiler inherits Lucy::Search::Query { /** Factory method returning a Matcher. * * @param reader A SegReader. - * @param need_score Indicate whether the Matcher must implement Score(). + * @param need_score Indicate whether the Matcher must implement [Score()](clownfish:method:Matcher:Score). * @return a Matcher, or NULL if the Matcher would have matched no * documents. */ @@ -102,7 +102,7 @@ public class Lucy::Search::Compiler inherits Lucy::Search::Query { Get_Parent(Compiler *self); /** Compute and return a raw weighting factor. (This quantity is used by - * Normalize()). By default, simply returns 1.0. + * [Normalize()](clownfish:method:Normalize)). By default, simply returns 1.0. */ public float Sum_Of_Squared_Weights(Compiler *self); @@ -122,13 +122,13 @@ public class Lucy::Search::Compiler inherits Lucy::Search::Query { /** Take a newly minted Compiler object and apply query-specific * normalization factors. Should be invoked by Query subclasses during - * Make_Compiler() for top-level nodes. + * [Make_Compiler()](clownfish:method:Make_Compiler) for top-level nodes. * * For a TermQuery, the scoring formula is approximately: * * (tf_d * idf_t / norm_d) * (tf_q * idf_t / norm_q) * - * Normalize() is theoretically concerned with applying the second half of + * [Normalize()](clownfish:method: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/82d38667/core/Lucy/Search/LeafQuery.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/LeafQuery.cfh b/core/Lucy/Search/LeafQuery.cfh index 1d6db24..586e407 100644 --- a/core/Lucy/Search/LeafQuery.cfh +++ b/core/Lucy/Search/LeafQuery.cfh @@ -19,7 +19,7 @@ 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() method. + * [QueryParser](clownfish:class:QueryParser)'s [Tree()](clownfish:method:QueryParser:Tree) method. * Ultimately, they must be transformed, typically into either * [TermQuery](clownfish:class:TermQuery) or * [PhraseQuery](clownfish:class:PhraseQuery) objects, as attempting to http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Search/Matcher.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/Matcher.cfh b/core/Lucy/Search/Matcher.cfh index 3d242b5..3bd1d4c 100644 --- a/core/Lucy/Search/Matcher.cfh +++ b/core/Lucy/Search/Matcher.cfh @@ -19,7 +19,7 @@ parcel Lucy; /** Match a set of document ids. * * A Matcher iterates over a set of ascending document ids. Some Matchers - * implement Score() and can assign relevance scores to the docs that they + * implement [Score()](clownfish:method:Score) and can assign relevance scores to the docs that they * match. Other implementations may be match-only. */ @@ -38,7 +38,7 @@ public abstract class Lucy::Search::Matcher inherits Clownfish::Obj { Next(Matcher *self); /** Advance the iterator to the first doc id greater than or equal to - * `target`. The default implementation simply calls Next() + * `target`. The default implementation simply calls [Next()](clownfish:method:Next) * over and over, but subclasses have the option of doing something more * efficient. * @@ -50,14 +50,14 @@ public abstract class Lucy::Search::Matcher inherits Clownfish::Obj { Advance(Matcher *self, int32_t target); /** Return the current doc id. Valid only after a successful call to - * Next() or Advance() and must not be called otherwise. + * [Next()](clownfish:method:Next) or [Advance()](clownfish:method:Advance) and must not be called otherwise. */ public abstract int32_t Get_Doc_ID(Matcher *self); /** Return the score of the current document. * - * Only Matchers which are used for scored search need implement Score(). + * Only Matchers which are used for scored search need implement [Score()](clownfish:method:Score). */ public abstract float Score(Matcher *self); http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Search/ORMatcher.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/ORMatcher.cfh b/core/Lucy/Search/ORMatcher.cfh index 51bb8d8..a97d29b 100644 --- a/core/Lucy/Search/ORMatcher.cfh +++ b/core/Lucy/Search/ORMatcher.cfh @@ -19,7 +19,7 @@ parcel Lucy; __C__ #include "Lucy/Search/Matcher.h" -/* A wrapper for a Matcher which caches the result of Matcher_Get_Doc_ID(). +/* A wrapper for a Matcher which caches the result of [Matcher_Get_Doc_ID()](clownfish:method:Matcher_Get_Doc_ID). */ typedef struct lucy_HeapedMatcherDoc { lucy_Matcher *matcher; http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Search/Query.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/Query.cfh b/core/Lucy/Search/Query.cfh index 523ae1b..56a7aa5 100644 --- a/core/Lucy/Search/Query.cfh +++ b/core/Lucy/Search/Query.cfh @@ -23,13 +23,13 @@ parcel Lucy; * * 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() method, which outputs an abstract syntax tree built up from various + * [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 * 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 + * 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 * can actually match and score documents. */ @@ -54,7 +54,7 @@ public class Lucy::Search::Query inherits Clownfish::Obj { * @param boost A scoring multiplier. * @param subordinate Indicates whether the Query is a subquery (as * opposed to a top-level query). If false, the implementation must - * invoke Normalize() on the newly minted Compiler object before returning + * invoke [Normalize()](clownfish:method: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/82d38667/core/Lucy/Search/QueryParser.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Search/QueryParser.cfh b/core/Lucy/Search/QueryParser.cfh index 2749147..4fcd3d2 100644 --- a/core/Lucy/Search/QueryParser.cfh +++ b/core/Lucy/Search/QueryParser.cfh @@ -32,7 +32,7 @@ parcel Lucy; * * Logical groups, delimited by parentheses. * * Phrases, delimited by double quotes. * - * Additionally, the following syntax can be enabled via Set_Heed_Colons(): + * Additionally, the following syntax can be enabled via [Set_Heed_Colons()](clownfish:method:Set_Heed_Colons): * * * Field-specific constructs, in the form of 'fieldname:termtext' or * 'fieldname:(foo bar)'. (The field specified by 'fieldname:' will be @@ -76,7 +76,7 @@ public class Lucy::Search::QueryParser nickname QParser String *default_boolop = NULL, VArray *fields = NULL); /** Build a Query object from the contents of a query string. At present, - * implemented internally by calling Tree(), Expand(), and Prune(). + * implemented internally by calling [Tree()](clownfish:method:Tree), [Expand()](clownfish:method:Expand), and [Prune()](clownfish:method:Prune). * * @param query_string The string to be parsed. May be NULL. * @return a Query. @@ -90,8 +90,8 @@ public class Lucy::Search::QueryParser nickname QParser * well. Internal nodes will be objects which subclass PolyQuery: * ANDQuery, ORQuery, NOTQuery, and RequiredOptionalQuery. * - * The output of Tree() is an intermediate form which must be passed - * through Expand() before being used to feed a search. + * The output of [Tree()](clownfish:method:Tree) is an intermediate form which must be passed + * through [Expand()](clownfish:method:Expand) before being used to feed a search. * * @param query_string The string to be parsed. * @return a Query. @@ -100,7 +100,7 @@ public class Lucy::Search::QueryParser nickname QParser Tree(QueryParser *self, String *query_string); /** Walk the hierarchy of a Query tree, descending through all PolyQuery - * nodes and calling Expand_Leaf() on any LeafQuery nodes encountered. + * nodes and calling [Expand_Leaf()](clownfish:method:Expand_Leaf) on any LeafQuery nodes encountered. * * @param query A Query object. * @return A Query -- usually the same one that was supplied after @@ -124,23 +124,23 @@ public class Lucy::Search::QueryParser nickname QParser Expand_Leaf(QueryParser *self, Query *query); /** Prevent certain Query structures from returning too many results. - * Query objects built via Tree() and Expand() can generate "return the + * Query objects built via [Tree()](clownfish:method:Tree) and [Expand()](clownfish:method:Expand) can generate "return the * world" result sets, such as in the case of - * `NOT a_term_not_in_the_index`; Prune() walks the hierarchy + * `NOT a_term_not_in_the_index`; [Prune()](clownfish:method:Prune) walks the hierarchy * and eliminates such branches. * * 'NOT foo' => [NOMATCH] * 'foo OR NOT bar' => 'foo' * 'foo OR (-bar AND -baz) => 'foo' * - * Prune() also eliminates some double-negative constructs -- even though + * [Prune()](clownfish:method:Prune) also eliminates some double-negative constructs -- even though * such constructs may not actually return the world: * * 'foo AND -(-bar)' => 'foo' * * In this example, safety is taking precedence over logical consistency. - * If you want logical consistency instead, call Tree() then Expand(), - * skipping Prune(). + * If you want logical consistency instead, call [Tree()](clownfish:method:Tree) then [Expand()](clownfish:method:Expand), + * skipping [Prune()](clownfish:method:Prune). * * * @param query A Query. http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Store/DirHandle.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/DirHandle.cfh b/core/Lucy/Store/DirHandle.cfh index f300285..c0e1e28 100644 --- a/core/Lucy/Store/DirHandle.cfh +++ b/core/Lucy/Store/DirHandle.cfh @@ -50,7 +50,7 @@ abstract class Lucy::Store::DirHandle nickname DH Get_Dir(DirHandle *self); /** Return the path of the current entry. The value is only valid when - * Next() has returned successfully. + * [Next()](clownfish:method:Next) has returned successfully. */ incremented String* Get_Entry(DirHandle *self); @@ -66,7 +66,7 @@ abstract class Lucy::Store::DirHandle nickname DH abstract bool Entry_Is_Symlink(DirHandle *self); - /** Invokes Close(), but ignores any errors. + /** Invokes [Close()](clownfish:method:Close), but ignores any errors. */ public void Destroy(DirHandle *self); http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Store/FileHandle.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/FileHandle.cfh b/core/Lucy/Store/FileHandle.cfh index c1a9669..4d7664d 100644 --- a/core/Lucy/Store/FileHandle.cfh +++ b/core/Lucy/Store/FileHandle.cfh @@ -125,7 +125,7 @@ abstract class Lucy::Store::FileHandle nickname FH nullable String* Get_Path(FileHandle *self); - /** Invokes Close(), but ignores whether it succeeds or fails. + /** Invokes [Close()](clownfish:method:Close), but ignores whether it succeeds or fails. */ public void Destroy(FileHandle *self); http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Store/Folder.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/Folder.cfh b/core/Lucy/Store/Folder.cfh index 030a981..661bf1c 100644 --- a/core/Lucy/Store/Folder.cfh +++ b/core/Lucy/Store/Folder.cfh @@ -19,7 +19,7 @@ parcel Lucy; /** Abstract class representing a directory. * * A "file" within a Folder might be a real file on disk -- or it might be a - * RAM buffer. Similarly, Delete() might delete a file from the file system, or + * RAM buffer. Similarly, [Delete()](clownfish:method: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, http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Store/InStream.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/InStream.cfh b/core/Lucy/Store/InStream.cfh index 4bf7d27..c0a6516 100644 --- a/core/Lucy/Store/InStream.cfh +++ b/core/Lucy/Store/InStream.cfh @@ -119,8 +119,8 @@ class Lucy::Store::InStream inherits Clownfish::Obj { Buf(InStream *self, size_t request); /** Set the buf to a new value, checking for overrun. The idiom is for - * the caller to call Buf(), use no more bytes than requested, then use - * Advance_Buf() to update the InStream object. + * the caller to call [Buf()](clownfish:method:Buf), use no more bytes than requested, then use + * [Advance_Buf()](clownfish:method: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/82d38667/core/Lucy/Store/Lock.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/Lock.cfh b/core/Lucy/Store/Lock.cfh index 1e20aaa..59eab09 100644 --- a/core/Lucy/Store/Lock.cfh +++ b/core/Lucy/Store/Lock.cfh @@ -43,7 +43,7 @@ public abstract class Lucy::Store::Lock inherits Clownfish::Obj { * consist solely of characters matching [-_.A-Za-z0-9]. * @param host A unique per-machine identifier. * @param timeout Time in milliseconds to keep retrying before abandoning - * the attempt to Obtain() a lock. + * the attempt to [Obtain()](clownfish:method:Obtain) a lock. * @param interval Time in milliseconds between retries. */ public inert Lock* @@ -55,7 +55,7 @@ public abstract class Lucy::Store::Lock inherits Clownfish::Obj { public abstract bool Shared(Lock *self); - /** Call Request() once per `interval` until Request() returns + /** Call [Request()](clownfish:method:Request) once per `interval` until [Request()](clownfish:method:Request) returns * success or the `timeout` has been reached. * * @return true on success, false on failure (sets Err_error). @@ -65,12 +65,12 @@ public abstract class Lucy::Store::Lock inherits Clownfish::Obj { /** Make one attempt to acquire the lock. * - * The semantics of Request() differ depending on whether Shared() returns - * true. If the Lock is Shared(), then Request() should not fail if + * The semantics of [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 * another lock is held against the resource identified by * `name` (though it might fail for other reasons). If it is - * not Shared() -- i.e. it's an exclusive (write) lock -- then other locks - * should cause Request() to fail. + * not [Shared()](clownfish:method:Shared) -- i.e. it's an exclusive (write) lock -- then other locks + * should cause [Request()](clownfish:method:Request) to fail. * * @return true on success, false on failure (sets Err_error). */ http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Store/LockFactory.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/LockFactory.cfh b/core/Lucy/Store/LockFactory.cfh index b96199d..d68e008 100644 --- a/core/Lucy/Store/LockFactory.cfh +++ b/core/Lucy/Store/LockFactory.cfh @@ -40,27 +40,27 @@ public class Lucy::Store::LockFactory nickname LockFact public inert LockFactory* init(LockFactory *self, Folder *folder, String *host); - /** Return a Lock object, which, once Obtain() returns successfully, + /** Return a Lock object, which, once [Obtain()](clownfish:method:Lock:Obtain) returns successfully, * maintains an exclusive lock on a resource. * * @param name A file-system-friendly id which identifies the * resource to be locked. * @param timeout Time in milliseconds to keep retrying before abandoning - * the attempt to Obtain() a lock. + * the attempt to [Obtain()](clownfish:method:Lock:Obtain) a lock. * @param interval Time in milliseconds between retries. */ public incremented Lock* Make_Lock(LockFactory *self, String *name, int32_t timeout = 0, int32_t interval = 100); - /** Return a Lock object for which Shared() returns true, and which - * maintains a non-exclusive lock on a resource once Obtain() returns + /** Return a Lock object for which [Shared()](clownfish:method:Lock:Shared) returns true, and which + * maintains a non-exclusive lock on a resource once [Obtain()](clownfish:method:Lock:Obtain) returns * success. * * @param name A file-system-friendly id which identifies the * resource to be locked. * @param timeout Time in milliseconds to keep retrying before abandoning - * the attempt to Obtain() a lock. + * the attempt to [Obtain()](clownfish:method:Lock:Obtain) a lock. * @param interval Time in milliseconds between retries. */ public incremented Lock* http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Store/SharedLock.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Store/SharedLock.cfh b/core/Lucy/Store/SharedLock.cfh index d8a8bc7..b4a6462 100644 --- a/core/Lucy/Store/SharedLock.cfh +++ b/core/Lucy/Store/SharedLock.cfh @@ -23,13 +23,13 @@ parcel Lucy; * implementing the same list of methods. It differs from Lock only in the * semantics of two methods. * - * First, Obtain() will not fail if another lock is held against the resource + * First, [Obtain()](clownfish:method:Obtain) will not fail if another lock is held against the resource * identified by `name` (though it might fail for other reasons). * - * Second, Is_Locked() returns true so long as some lock, somewhere is holding + * Second, [Is_Locked()](clownfish:method:Is_Locked) returns true so long as some lock, somewhere is holding * a lock on `name`. That lock could be this instance, or it could - * be another -- so is entirely possible to call Release() successfully on a - * SharedLock object yet still have Is_Locked() return true. + * be another -- so is entirely possible to call [Release()](clownfish:method:Release) successfully on a + * SharedLock object yet still have [Is_Locked()](clownfish:method:Is_Locked) return true. * * As currently implemented, SharedLock differs from Lock in that each caller * gets its own lockfile. Lockfiles still have filenames which begin with the @@ -51,7 +51,7 @@ class Lucy::Store::SharedLock nickname ShLock * @param name String identifying the resource to be locked. * @param host An identifier which should be unique per-machine. * @param timeout Time in milliseconds to keep retrying before abandoning - * the attempt to Obtain() a lock. + * the attempt to [Obtain()](clownfish:method:Obtain) a lock. * @param interval Time in milliseconds between retries. */ public inert SharedLock* http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Test/Plan/TestArchitecture.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Test/Plan/TestArchitecture.cfh b/core/Lucy/Test/Plan/TestArchitecture.cfh index d86b1b8..dc4883b 100644 --- a/core/Lucy/Test/Plan/TestArchitecture.cfh +++ b/core/Lucy/Test/Plan/TestArchitecture.cfh @@ -17,7 +17,7 @@ parcel TestLucy; /** - * Returns absurdly low values for Index_Interval() and Skip_Interval(). + * Returns absurdly low values for [Index_Interval()](clownfish:method:Index_Interval) and [Skip_Interval()](clownfish:method:Skip_Interval). */ class Lucy::Test::Plan::TestArchitecture nickname TestArch http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Test/TestSchema.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Test/TestSchema.cfh b/core/Lucy/Test/TestSchema.cfh index 87dd41a..219698b 100644 --- a/core/Lucy/Test/TestSchema.cfh +++ b/core/Lucy/Test/TestSchema.cfh @@ -19,7 +19,7 @@ parcel TestLucy; /** Schema for use by the test suite. * * Exposes problems faced by much larger indexes by using an TestArchitecture, - * which returns absurdly low values for Index_Interval() and Skip_Interval(). + * which returns absurdly low values for [Index_Interval()](clownfish:method:Index_Interval) and [Skip_Interval()](clownfish:method:Skip_Interval). */ class Lucy::Test::TestSchema inherits Lucy::Plan::Schema { http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Util/Debug.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Util/Debug.cfh b/core/Lucy/Util/Debug.cfh index 9e81d04..5ba535a 100644 --- a/core/Lucy/Util/Debug.cfh +++ b/core/Lucy/Util/Debug.cfh @@ -98,7 +98,7 @@ __C__ /** Abort on error if test fails. * - * Note: unlike the system assert(), this ASSERT() is #ifdef LUCY_DEBUG. + * Note: unlike the system assert(), this [ASSERT()](clownfish:method:ASSERT) is #ifdef LUCY_DEBUG. */ #define LUCY_ASSERT(test , args...) \ do { \ http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Util/Freezer.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Util/Freezer.cfh b/core/Lucy/Util/Freezer.cfh index 5de2474..0cde753 100644 --- a/core/Lucy/Util/Freezer.cfh +++ b/core/Lucy/Util/Freezer.cfh @@ -43,7 +43,7 @@ inert class Lucy::Util::Freezer { /** Return a representation of the object using only scalars, hashes, and * arrays. Some classes support JSON serialization via dump() and its * companion, load(); for others, dump() is only a debugging aid. - * The default simply calls To_String(). + * The default simply calls [To_String()](clownfish:method:To_String). */ inert incremented Obj* dump(Obj *obj); http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Util/PriorityQueue.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Util/PriorityQueue.cfh b/core/Lucy/Util/PriorityQueue.cfh index 2480bb5..7c0e267 100644 --- a/core/Lucy/Util/PriorityQueue.cfh +++ b/core/Lucy/Util/PriorityQueue.cfh @@ -53,8 +53,8 @@ class Lucy::Util::PriorityQueue nickname PriQ bool Insert(PriorityQueue *self, decremented Obj *element); - /** Equivalent to Insert(), except for the return value. If the Queue has - * room, the element is inserted and Jostle() returns NULL. If not, then + /** Equivalent to [Insert()](clownfish:method:Insert), except for the return value. If the Queue has + * room, the element is inserted and [Jostle()](clownfish:method:Jostle) returns NULL. If not, then * the item which falls out of the bottom of the Queue is returned. */ incremented nullable Obj* http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Util/SortExternal.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Util/SortExternal.cfh b/core/Lucy/Util/SortExternal.cfh index 7e8439b..d8420ff 100644 --- a/core/Lucy/Util/SortExternal.cfh +++ b/core/Lucy/Util/SortExternal.cfh @@ -19,19 +19,19 @@ parcel Lucy; /** Abstract external sorter. * * SortExternal objects are sort pools which allow you to sort huge - * collections of elements. To achieve this, you Feed() all items into the - * SortExternal object, Flip() it from write mode to read mode, then Fetch() + * collections of elements. To achieve this, you [Feed()](clownfish:method:Feed) all items into the + * SortExternal object, [Flip()](clownfish:method:Flip) it from write mode to read mode, then [Fetch()](clownfish:method:Fetch) * the elements one at a time in sorted order. * * It's expected that the total memory footprint of the buffered sortable * items will eventually exceed a specified threshold; at that point, the - * SortExternal object will call the abstract method Flush(). It's expected - * that Flush() implementations will empty out the current buffer, write a + * SortExternal object will call the abstract method [Flush()](clownfish:method:Flush). It's expected + * that [Flush()](clownfish:method:Flush) implementations will empty out the current buffer, write a * sorted "run" to external storage, and add a new child SortExternal object * to the top level object's "runs" array to represent the flushed content. * * During the read phase, the child sortex objects retrieve elements from - * external storage by calling the abstract method Refill(). The top-level + * external storage by calling the abstract method [Refill()](clownfish:method:Refill). The top-level * SortExternal object then interleaves multiple sorted streams to produce a * single unified stream of sorted items. */ @@ -63,7 +63,7 @@ abstract class Lucy::Util::SortExternal nickname SortEx * * Presumably this entails sorting everything, writing the sorted elements * to disk, spawning a child object to represent those elements, and - * adding that child to the top-level object via Add_Run(). + * adding that child to the top-level object via [Add_Run()](clownfish:method:Add_Run). */ abstract void Flush(SortExternal *self); @@ -79,13 +79,13 @@ abstract class Lucy::Util::SortExternal nickname SortEx Flip(SortExternal *self); /** Fetch the next sorted item from the sort pool. Invalid prior to - * calling Flip(). Returns NULL when all elements have been exhausted. + * calling [Flip()](clownfish:method:Flip). Returns NULL when all elements have been exhausted. */ incremented nullable Obj* Fetch(SortExternal *self); /** Preview the next item that Fetch will return, but don't pop it. - * Invalid prior to calling Flip(). + * Invalid prior to calling [Flip()](clownfish:method:Flip). */ nullable Obj* Peek(SortExternal *self); http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/Lucy/Util/Stepper.cfh ---------------------------------------------------------------------- diff --git a/core/Lucy/Util/Stepper.cfh b/core/Lucy/Util/Stepper.cfh index 36ed485..73d0003 100644 --- a/core/Lucy/Util/Stepper.cfh +++ b/core/Lucy/Util/Stepper.cfh @@ -44,7 +44,7 @@ class Lucy::Util::Stepper inherits Clownfish::Obj { Reset(Stepper* self); /** Update internal state to reflect `value` and write a frame - * to `outstream` that can be read using Read_Key_Frame(). + * to `outstream` that can be read using [Read_Key_Frame()](clownfish:method:Read_Key_Frame). * * @param outstream An OutStream. * @param value State information. @@ -53,7 +53,7 @@ class Lucy::Util::Stepper inherits Clownfish::Obj { Write_Key_Frame(Stepper *self, OutStream *outstream, Obj *value); /** Update internal state to reflect `value` and write a frame - * to `outstream` that can be read using Read_Delta(). + * to `outstream` that can be read using [Read_Delta()](clownfish:method:Read_Delta). * * @param outstream An OutStream. * @param value State information. http://git-wip-us.apache.org/repos/asf/lucy/blob/82d38667/core/LucyX/Search/MockMatcher.cfh ---------------------------------------------------------------------- diff --git a/core/LucyX/Search/MockMatcher.cfh b/core/LucyX/Search/MockMatcher.cfh index 27c23c6..f25877a 100644 --- a/core/LucyX/Search/MockMatcher.cfh +++ b/core/LucyX/Search/MockMatcher.cfh @@ -29,7 +29,7 @@ class LucyX::Search::MockMatcher inherits Lucy::Search::Matcher { /** * @param doc_ids An array of matching doc ids. * @param scores Float scores corresponding to the doc ids array. If not - * supplied, calling Score() will throw an exception. + * supplied, calling [Score()](clownfish:method:Score) will throw an exception. */ inert incremented MockMatcher* init(MockMatcher *self, I32Array *doc_ids, ByteBuf *scores = NULL);
