lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ccurr...@apache.org
Subject svn commit: r1394820 [4/6] - in /lucene.net/trunk: src/contrib/Analyzers/ src/contrib/Analyzers/AR/ src/contrib/Analyzers/BR/ src/contrib/Analyzers/CJK/ src/contrib/Analyzers/Compound/ src/contrib/Analyzers/Compound/Hyphenation/ src/contrib/Analyzers/C...
Date Fri, 05 Oct 2012 21:22:59 GMT
Modified: lucene.net/trunk/src/core/Index/IndexReader.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Index/IndexReader.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Index/IndexReader.cs (original)
+++ lucene.net/trunk/src/core/Index/IndexReader.cs Fri Oct  5 21:22:51 2012
@@ -231,7 +231,7 @@ namespace Lucene.Net.Index
 		/// <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
 		/// </param>
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public static IndexReader Open(IndexCommit commit, bool readOnly)
 		{
 			return Open(commit.Directory, null, commit, readOnly, DEFAULT_TERMS_INDEX_DIVISOR);
@@ -253,7 +253,7 @@ namespace Lucene.Net.Index
 		/// <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
 		/// </param>
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public static IndexReader Open(Directory directory, IndexDeletionPolicy deletionPolicy, bool readOnly)
 		{
 			return Open(directory, deletionPolicy, null, readOnly, DEFAULT_TERMS_INDEX_DIVISOR);
@@ -287,7 +287,7 @@ namespace Lucene.Net.Index
 		/// to -1 to skip loading the terms index entirely.
 		/// </param>
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public static IndexReader Open(Directory directory, IndexDeletionPolicy deletionPolicy, bool readOnly, int termInfosIndexDivisor)
 		{
 			return Open(directory, deletionPolicy, null, readOnly, termInfosIndexDivisor);
@@ -311,7 +311,7 @@ namespace Lucene.Net.Index
 		/// <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
 		/// </param>
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public static IndexReader Open(IndexCommit commit, IndexDeletionPolicy deletionPolicy, bool readOnly)
 		{
 			return Open(commit.Directory, deletionPolicy, commit, readOnly, DEFAULT_TERMS_INDEX_DIVISOR);
@@ -347,7 +347,7 @@ namespace Lucene.Net.Index
 		/// to -1 to skip loading the terms index entirely.
 		/// </param>
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public static IndexReader Open(IndexCommit commit, IndexDeletionPolicy deletionPolicy, bool readOnly, int termInfosIndexDivisor)
 		{
 			return Open(commit.Directory, deletionPolicy, commit, readOnly, termInfosIndexDivisor);
@@ -401,7 +401,7 @@ namespace Lucene.Net.Index
 		/// 
 		/// </summary>
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public virtual IndexReader Reopen()
 		{
 			lock (this)
@@ -456,7 +456,7 @@ namespace Lucene.Net.Index
 		/// <p/>
 		/// </summary>
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public virtual System.Object Clone()
 		{
 			throw new System.NotSupportedException("This reader does not implement clone()");
@@ -466,7 +466,7 @@ namespace Lucene.Net.Index
 		/// reader cannot open a writeable reader.  
 		/// </summary>
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public virtual IndexReader Clone(bool openReadOnly)
 		{
 			lock (this)
@@ -492,7 +492,7 @@ namespace Lucene.Net.Index
 		/// <see cref="IsCurrent()" /> instead. 
 		/// </summary>
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public static long LastModified(Directory directory2)
 		{
 			return (long) ((System.Int64) new AnonymousClassFindSegmentsFile(directory2, directory2).Run());
@@ -508,7 +508,7 @@ namespace Lucene.Net.Index
 		/// <returns> version number.
 		/// </returns>
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public static long GetCurrentVersion(Directory directory)
 		{
 			return SegmentInfos.ReadCurrentVersion(directory);
@@ -525,7 +525,7 @@ namespace Lucene.Net.Index
 		/// <returns> commit userData.
 		/// </returns>
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		/// <summary> 
 		/// </summary>
 		/// <seealso cref="GetCommitUserData(Store.Directory)">
@@ -540,7 +540,7 @@ namespace Lucene.Net.Index
 	    /// 
 	    /// <p/>
 	    /// If this reader is based on a Directory (ie, was created by calling
-	    /// <see cref="Open(Lucene.Net.Store.Directory)" />, or <see cref="Reopen()" /> 
+	    /// <see cref="Open(Lucene.Net.Store.Directory, bool)" />, or <see cref="Reopen()" /> 
 	    /// on a reader based on a Directory), then
 	    /// this method returns the version recorded in the commit that the reader
 	    /// opened. This version is advanced every time <see cref="IndexWriter.Commit()" /> is
@@ -607,7 +607,7 @@ namespace Lucene.Net.Index
 		/// 
 		/// </summary>
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		/// <throws>  UnsupportedOperationException unless overridden in subclass </throws>
 		public virtual bool IsCurrent()
 	    {
@@ -725,7 +725,7 @@ namespace Lucene.Net.Index
 		/// 
 		/// </summary>
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public virtual Document Document(int n)
 		{
 			EnsureOpen();
@@ -743,7 +743,7 @@ namespace Lucene.Net.Index
         /// 
         /// </summary>
         /// <throws>  CorruptIndexException if the index is corrupt </throws>
-        /// <throws>  IOException if there is a low-level IO error </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 	    public Document this[int doc]
 	    {
 	        get { return Document(doc); }
@@ -776,7 +776,7 @@ namespace Lucene.Net.Index
 		/// <see cref="Lucene.Net.Documents.Document" /> at the nth position
 		/// </returns>
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		/// <seealso cref="IFieldable">
 		/// </seealso>
 		/// <seealso cref="Lucene.Net.Documents.FieldSelector">
@@ -803,45 +803,42 @@ namespace Lucene.Net.Index
 			return Norms(field) != null;
 		}
 
-		/// <summary>Returns the byte-encoded normalization factor for the named field of
+		/// <summary>
+		/// Returns the byte-encoded normalization factor for the named field of
 		/// every document.  This is used by the search code to score documents.
-		/// 
 		/// </summary>
-		/// <seealso>
-		///   <cref>Lucene.Net.Documents.AbstractField.SetBoost(float)</cref>
-		/// </seealso>
+        /// <seealso cref="Lucene.Net.Documents.AbstractField.Boost" />
 		public abstract byte[] Norms(System.String field);
 		
-		/// <summary>Reads the byte-encoded normalization factor for the named field of every
+		/// <summary>
+		/// Reads the byte-encoded normalization factor for the named field of every
 		/// document.  This is used by the search code to score documents.
-		/// 
 		/// </summary>
-		/// <seealso cref="Lucene.Net.Documents.AbstractField.SetBoost(float)">
-		/// </seealso>
+		/// <seealso cref="Lucene.Net.Documents.AbstractField.Boost" />
 		public abstract void  Norms(System.String field, byte[] bytes, int offset);
 		
 		/// <summary>Expert: Resets the normalization factor for the named field of the named
-		/// document.  The norm represents the product of the field's <see cref="IFieldable.SetBoost(float)">boost</see>
+		/// document.  The norm represents the product of the field's <see cref="IFieldable.Boost">boost</see>
         /// and its <see cref="Similarity.LengthNorm(String,int)">length normalization</see>.  Thus, to preserve the length normalization
 		/// values when resetting this, one should base the new value upon the old.
 		/// 
 		/// <b>NOTE:</b> If this field does not store norms, then
 		/// this method call will silently do nothing.
-		/// 
 		/// </summary>
-		/// <seealso cref="Norms(String)">
-		/// </seealso>
-		/// <seealso cref="Similarity.DecodeNorm(byte)">
-		/// </seealso>
-		/// <throws>  StaleReaderException if the index has changed </throws>
-		/// <summary>  since this reader was opened
-		/// </summary>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  LockObtainFailedException if another writer </throws>
-		/// <summary>  has this index open (<c>write.lock</c> could not
-		/// be obtained)
-		/// </summary>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <seealso cref="Norms(String)" />
+		/// <seealso cref="Similarity.DecodeNorm(byte)" />
+		/// <exception cref="StaleReaderException">
+        /// If the index has changed since this reader was opened
+		/// </exception>
+        /// <exception cref="CorruptIndexException">
+        /// If the index is corrupt
+		/// </exception>
+		/// <exception cref="LockObtainFailedException">
+        /// If another writer has this index open (<c>write.lock</c> could not be obtained)
+		/// </exception>
+		/// <exception cref="System.IO.IOException">
+        /// If there is a low-level IO error
+		/// </exception>
 		public virtual void  SetNorm(int doc, String field, byte value)
 		{
 			lock (this)
@@ -856,24 +853,23 @@ namespace Lucene.Net.Index
 		/// <summary>Implements setNorm in subclass.</summary>
 		protected internal abstract void  DoSetNorm(int doc, System.String field, byte value_Renamed);
 		
-		/// <summary>Expert: Resets the normalization factor for the named field of the named
-		/// document.
-		/// 
-		/// </summary>
-		/// <seealso cref="Norms(String)">
-		/// </seealso>
-		/// <seealso cref="Similarity.DecodeNorm(byte)">
-		/// 
-		/// </seealso>
-		/// <throws>  StaleReaderException if the index has changed </throws>
-		/// <summary>  since this reader was opened
+		/// <summary>
+		/// Expert: Resets the normalization factor for the named field of the named document.
 		/// </summary>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  LockObtainFailedException if another writer </throws>
-		/// <summary>  has this index open (<c>write.lock</c> could not
-		/// be obtained)
-		/// </summary>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <seealso cref="Norms(String)" />
+        /// <seealso cref="Similarity.DecodeNorm(byte)" />
+        /// <exception cref="StaleReaderException">
+        /// If the index has changed since this reader was opened
+        /// </exception>
+        /// <exception cref="CorruptIndexException">
+        /// If the index is corrupt
+        /// </exception>
+        /// <exception cref="LockObtainFailedException">
+        /// If another writer has this index open (<c>write.lock</c> could not be obtained)
+        /// </exception>
+        /// <exception cref="System.IO.IOException">
+        /// If there is a low-level IO error
+        /// </exception>
 		public virtual void  SetNorm(int doc, System.String field, float value)
 		{
 			EnsureOpen();
@@ -887,7 +883,9 @@ namespace Lucene.Net.Index
 		/// on the resulting enumeration before calling other methods such as
 		/// <see cref="TermEnum.Term" />.
 		/// </summary>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <exception cref="System.IO.IOException">
+        /// If there is a low-level IO error 
+		/// </exception>
 		public abstract TermEnum Terms();
 		
 		/// <summary>Returns an enumeration of all terms starting at a given term. If
@@ -895,12 +893,14 @@ namespace Lucene.Net.Index
 		/// first term greater than the supplied term. The enumeration is
 		/// ordered by Term.compareTo(). Each term is greater than all that
 		/// precede it in the enumeration.
-		/// </summary>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+        /// </summary>
+        /// <exception cref="System.IO.IOException">
+        /// If there is a low-level IO error
+        /// </exception>
 		public abstract TermEnum Terms(Term t);
-		
-		/// <summary>Returns the number of documents containing the term <c>t</c>.</summary>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+
+        /// <summary>Returns the number of documents containing the term <c>t</c>.</summary>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public abstract int DocFreq(Term t);
 		
 		/// <summary>Returns an enumeration of all the documents which contain
@@ -914,8 +914,8 @@ namespace Lucene.Net.Index
 		/// </list>
 		/// <p/>The enumeration is ordered by document number.  Each document number
 		/// is greater than all that precede it in the enumeration.
-		/// </summary>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+        /// </summary>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public virtual TermDocs TermDocs(Term term)
 		{
 			EnsureOpen();
@@ -925,7 +925,7 @@ namespace Lucene.Net.Index
 		}
 
         /// <summary>Returns an unpositioned <see cref="Lucene.Net.Index.TermDocs" /> enumerator.</summary>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public abstract TermDocs TermDocs();
 		
 		/// <summary>Returns an enumeration of all the documents which contain
@@ -943,8 +943,8 @@ namespace Lucene.Net.Index
 		/// <p/> This positional information facilitates phrase and proximity searching.
 		/// <p/>The enumeration is ordered by document number.  Each document number is
 		/// greater than all that precede it in the enumeration.
-		/// </summary>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+        /// </summary>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public virtual TermPositions TermPositions(Term term)
 		{
 			EnsureOpen();
@@ -952,30 +952,29 @@ namespace Lucene.Net.Index
 			termPositions.Seek(term);
 			return termPositions;
 		}
-		
-		/// <summary>Returns an unpositioned <see cref="Lucene.Net.Index.TermPositions" /> enumerator.</summary>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+
+        /// <summary>Returns an unpositioned <see cref="Lucene.Net.Index.TermPositions" /> enumerator.</summary>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public abstract TermPositions TermPositions();
 		
 		
 		
-		/// <summary>Deletes the document numbered <c>docNum</c>.  Once a document is
+		/// <summary>
+		/// Deletes the document numbered <c>docNum</c>.  Once a document is
 		/// deleted it will not appear in TermDocs or TermPostitions enumerations.
 		/// Attempts to read its field with the <see cref="Document(int)" />
 		/// method will result in an error.  The presence of this document may still be
 		/// reflected in the <see cref="DocFreq" /> statistic, though
 		/// this will be corrected eventually as the index is further modified.
-		/// 
-		/// </summary>
-		/// <throws>  StaleReaderException if the index has changed </throws>
-		/// <summary> since this reader was opened
 		/// </summary>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  LockObtainFailedException if another writer </throws>
-		/// <summary>  has this index open (<c>write.lock</c> could not
-		/// be obtained)
-		/// </summary>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <exception cref="StaleReaderException">
+        /// If the index has changed since this reader was opened
+		/// </exception>
+		/// <exception cref="CorruptIndexException">If the index is corrupt</exception>
+		/// <exception cref="LockObtainFailedException">
+        /// If another writer has this index open (<c>write.lock</c> could not be obtained)
+        /// </exception>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public virtual void  DeleteDocument(int docNum)
 		{
 			lock (this)
@@ -994,26 +993,24 @@ namespace Lucene.Net.Index
 		protected internal abstract void  DoDelete(int docNum);
 		
 		
-		/// <summary>Deletes all documents that have a given <c>term</c> indexed.
+		/// <summary>
+		/// Deletes all documents that have a given <c>term</c> indexed.
 		/// This is useful if one uses a document field to hold a unique ID string for
 		/// the document.  Then to delete such a document, one merely constructs a
 		/// term with the appropriate field and the unique ID string as its text and
 		/// passes it to this method.
 		/// See <see cref="DeleteDocument(int)" /> for information about when this deletion will 
 		/// become effective.
-		/// 
 		/// </summary>
-		/// <returns> the number of documents deleted
-		/// </returns>
-		/// <throws>  StaleReaderException if the index has changed </throws>
-		/// <summary>  since this reader was opened
-		/// </summary>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  LockObtainFailedException if another writer </throws>
-		/// <summary>  has this index open (<c>write.lock</c> could not
-		/// be obtained)
-		/// </summary>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <returns>The number of documents deleted</returns>
+        /// <exception cref="StaleReaderException">
+        /// If the index has changed since this reader was opened
+        /// </exception>
+        /// <exception cref="CorruptIndexException">If the index is corrupt</exception>
+        /// <exception cref="LockObtainFailedException">
+        /// If another writer has this index open (<c>write.lock</c> could not be obtained)
+        /// </exception>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public virtual int DeleteDocuments(Term term)
 		{
 			EnsureOpen();
@@ -1038,16 +1035,15 @@ namespace Lucene.Net.Index
 		
 		/// <summary>Undeletes all documents currently marked as deleted in this index.
 		/// 
-		/// </summary>
-		/// <throws>  StaleReaderException if the index has changed </throws>
-		/// <summary>  since this reader was opened
-		/// </summary>
-		/// <throws>  LockObtainFailedException if another writer </throws>
-		/// <summary>  has this index open (<c>write.lock</c> could not
-		/// be obtained)
-		/// </summary>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+        /// </summary>
+        /// <exception cref="StaleReaderException">
+        /// If the index has changed since this reader was opened
+        /// </exception>
+        /// <exception cref="CorruptIndexException">If the index is corrupt</exception>
+        /// <exception cref="LockObtainFailedException">
+        /// If another writer has this index open (<c>write.lock</c> could not be obtained)
+        /// </exception>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public virtual void  UndeleteAll()
 		{
 			lock (this)
@@ -1062,7 +1058,8 @@ namespace Lucene.Net.Index
 		/// <summary>Implements actual undeleteAll() in subclass. </summary>
 		protected internal abstract void  DoUndeleteAll();
 		
-		/// <summary>Does nothing by default. Subclasses that require a write lock for
+		/// <summary>
+		/// Does nothing by default. Subclasses that require a write lock for
 		/// index modifications must implement this method. 
 		/// </summary>
 		protected internal virtual void  AcquireWriteLock()
@@ -1074,7 +1071,7 @@ namespace Lucene.Net.Index
 		}
 		
 		/// <summary> </summary>
-		/// <throws>  IOException </throws>
+		/// <exception cref="System.IO.IOException" />
 		public void  Flush()
 		{
 			lock (this)
@@ -1087,9 +1084,8 @@ namespace Lucene.Net.Index
 		/// <param name="commitUserData">Opaque Map (String -> String)
 		/// that's recorded into the segments file in the index,
 		/// and retrievable by <see cref="IndexReader.GetCommitUserData" />
-		///.
-		/// </param>
-		/// <throws>  IOException </throws>
+        /// </param>
+        /// <exception cref="System.IO.IOException" />
         public void Flush(IDictionary<string, string> commitUserData)
 		{
 			lock (this)
@@ -1106,7 +1102,7 @@ namespace Lucene.Net.Index
 		/// changes will have been committed to the index
 		/// (transactional semantics).
 		/// </summary>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
 		public /*protected internal*/ void  Commit()
 		{
 			lock (this)
@@ -1122,7 +1118,7 @@ namespace Lucene.Net.Index
 		/// changes will have been committed to the index
 		/// (transactional semantics).
 		/// </summary>
-		/// <throws>  IOException if there is a low-level IO error </throws>
+		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
         public void Commit(IDictionary<string, string> commitUserData)
 		{
 			lock (this)
@@ -1148,7 +1144,7 @@ namespace Lucene.Net.Index
         /// Also saves any new deletions to disk.
         /// No other methods should be called after this has been called.
         /// </summary>
-        /// <throws>  IOException if there is a low-level IO error </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
         public void Dispose()
         {
             Dispose(true);
@@ -1336,7 +1332,7 @@ namespace Lucene.Net.Index
 	        get { return this; }
 	    }
 
-	    /** Expert.  Warning: this returns null if the reader has
+	    /* Expert.  Warning: this returns null if the reader has
           *  no deletions 
           */
 

Modified: lucene.net/trunk/src/core/Index/IndexWriter.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Index/IndexWriter.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Index/IndexWriter.cs (original)
+++ lucene.net/trunk/src/core/Index/IndexWriter.cs Fri Oct  5 21:22:51 2012
@@ -103,7 +103,7 @@ namespace Lucene.Net.Index
 	/// the <see cref="MergePolicy" /> and the <see cref="MergeScheduler" />.
 	/// The <see cref="MergePolicy" /> is invoked whenever there are
 	/// changes to the segments in the index.  Its role is to
-	/// select which merges to do, if any, and return a <see cref="MergePolicy.MergeSpecification" />
+	/// select which merges to do, if any, and return a <see cref="Index.MergePolicy.MergeSpecification" />
 	/// describing the merges.  It
 	/// also selects merges to do for optimize().  (The default is
 	/// <see cref="LogByteSizeMergePolicy" />.  Then, the <see cref="MergeScheduler" />
@@ -167,7 +167,7 @@ namespace Lucene.Net.Index
 		}
 		
 		/// <summary> Default value for the write lock timeout (1,000).</summary>
-		/// <seealso cref="SetDefaultWriteLockTimeout">
+		/// <seealso cref="DefaultWriteLockTimeout">
 		/// </seealso>
 		public static long WRITE_LOCK_TIMEOUT = 1000;
 		
@@ -197,7 +197,7 @@ namespace Lucene.Net.Index
 		/// <summary> Default value is 10,000. Change using <see cref="SetMaxFieldLength(int)" />.</summary>
 		public const int DEFAULT_MAX_FIELD_LENGTH = 10000;
 		
-		/// <summary> Default value is 128. Change using <see cref="SetTermIndexInterval(int)" />.</summary>
+		/// <summary> Default value is 128. Change using <see cref="TermIndexInterval" />.</summary>
 		public const int DEFAULT_TERM_INDEX_INTERVAL = 128;
 		
 		/// <summary> Absolute hard maximum length for a term.  If a term
@@ -296,7 +296,7 @@ namespace Lucene.Net.Index
 		/// 
 		/// <p/>
 		/// Note that this is functionally equivalent to calling {#commit} and then
-		/// using <see cref="IndexReader.Open(string)" /> to open a new reader. But the turarnound
+		/// using <see cref="IndexReader.Open(Lucene.Net.Store.Directory, bool)" /> to open a new reader. But the turarnound
 		/// time of this method should be faster since it avoids the potentially
 		/// costly <see cref="Commit()" />.
 		/// <p/>
@@ -323,8 +323,8 @@ namespace Lucene.Net.Index
 		/// deletes, etc.  This means additional resources (RAM,
 		/// file descriptors, CPU time) will be consumed.<p/>
 		/// 
-		/// <p/>For lower latency on reopening a reader, you should call <see cref="SetMergedSegmentWarmer" /> 
-        /// to call <see cref="SetMergedSegmentWarmer" /> to
+		/// <p/>For lower latency on reopening a reader, you should call <see cref="MergedSegmentWarmer" /> 
+        /// to call <see cref="MergedSegmentWarmer" /> to
 		/// pre-warm a newly merged segment before it's committed
 		/// to the index. This is important for minimizing index-to-search 
         /// delay after a large merge.
@@ -358,7 +358,7 @@ namespace Lucene.Net.Index
 		/// any newly opened readers.
 		/// </summary>
 		/// <param name="termInfosIndexDivisor">Subsambles which indexed
-		/// terms are loaded into RAM. This has the same effect as <see cref="IndexWriter.SetTermIndexInterval" />
+		/// terms are loaded into RAM. This has the same effect as <see cref="IndexWriter.TermIndexInterval" />
 		/// except that setting
 		/// must be done at indexing time while this setting can be
 		/// set per reader.  When set to N, then one in every
@@ -936,7 +936,7 @@ namespace Lucene.Net.Index
 
 	    /// <summary>Expert: Return the Similarity implementation used by this IndexWriter.
 	    /// 
-	    /// <p/>This defaults to the current value of <see cref="Similarity.GetDefault()" />.
+	    /// <p/>This defaults to the current value of <see cref="Search.Similarity.Default" />.
 	    /// </summary>
 	    public virtual Similarity Similarity
 	    {
@@ -1439,9 +1439,9 @@ namespace Lucene.Net.Index
         /// The default merge policy (<see cref="LogByteSizeMergePolicy" />)
         /// also allows you to set this
         /// limit by net size (in MB) of the segment, using 
-        /// <see cref="LogByteSizeMergePolicy.SetMaxMergeMB" />.<p/>
+        /// <see cref="LogByteSizeMergePolicy.MaxMergeMB" />.<p/>
 	    /// </summary>
-	    /// <seealso cref="SetMaxMergeDocs">
+	    /// <seealso cref="MaxMergeDocs">
 	    /// </seealso>
 	    public virtual int MaxMergeDocs
 	    {
@@ -2304,7 +2304,7 @@ namespace Lucene.Net.Index
 		}
 		
 		/// <summary> Adds a document to this index, using the provided analyzer instead of the
-		/// value of <see cref="GetAnalyzer()" />.  If the document contains more than
+		/// value of <see cref="Analyzer" />.  If the document contains more than
 		/// <see cref="SetMaxFieldLength(int)" /> terms for a given field, the remainder are
 		/// discarded.
 		/// 
@@ -2666,7 +2666,7 @@ namespace Lucene.Net.Index
 		/// </summary>
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
 		/// <throws>  IOException if there is a low-level IO error </throws>
-		/// <seealso cref="LogMergePolicy.FindMergesForOptimize">
+		/// <seealso cref="Index.LogMergePolicy.FindMergesForOptimize">
 		/// </seealso>
 		public virtual void  Optimize()
 		{
@@ -2913,7 +2913,7 @@ namespace Lucene.Net.Index
 		/// searching.  expungeDeletes should be somewhat faster
 		/// than optimize since it does not insist on reducing the
 		/// index to a single segment (though, this depends on the
-		/// <see cref="MergePolicy" />; see <see cref="MergePolicy.FindMergesToExpungeDeletes" />.). Note that
+		/// <see cref="MergePolicy" />; see <see cref="Index.MergePolicy.FindMergesToExpungeDeletes" />.). Note that
 		/// this call does not first commit any buffered
 		/// documents, so you must do so yourself if necessary.
 		/// See also <seealso cref="ExpungeDeletes(bool)" />
@@ -3225,6 +3225,7 @@ namespace Lucene.Net.Index
 		/// it was when commit() was last called or when this
 		/// writer was first opened.  This also clears a previous 
 		/// call to <see cref="PrepareCommit()" />.
+		/// </summary>
 		/// <throws>  IOException if there is a low-level IO error </throws>
 		public virtual void  Rollback()
 		{
@@ -3329,7 +3330,7 @@ namespace Lucene.Net.Index
 		/// <p/>NOTE: this method will forcefully abort all merges
 		/// in progress.  If other threads are running <see cref="Optimize()" />
 		/// or any of the addIndexes methods, they
-		/// will receive <see cref="MergePolicy.MergeAbortedException" />s.
+		/// will receive <see cref="Index.MergePolicy.MergeAbortedException" />s.
 		/// </summary>
 		public virtual void  DeleteAll()
 		{

Modified: lucene.net/trunk/src/core/Index/LogByteSizeMergePolicy.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Index/LogByteSizeMergePolicy.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Index/LogByteSizeMergePolicy.cs (original)
+++ lucene.net/trunk/src/core/Index/LogByteSizeMergePolicy.cs Fri Oct  5 21:22:51 2012
@@ -26,12 +26,12 @@ namespace Lucene.Net.Index
 	public class LogByteSizeMergePolicy : LogMergePolicy
 	{
 		
-		/// <seealso cref="SetMinMergeMB">
+		/// <seealso cref="MinMergeMB">
 		/// </seealso>
 		public const double DEFAULT_MIN_MERGE_MB = 1.6;
 		
 		/// <summary>Default maximum segment size.  A segment of this size</summary>
-		/// <seealso cref="SetMaxMergeMB">
+		/// <seealso cref="MaxMergeMB">
 		/// </seealso>
 		public static readonly long DEFAULT_MAX_MERGE_MB = long.MaxValue;
 		

Modified: lucene.net/trunk/src/core/Index/LogMergePolicy.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Index/LogMergePolicy.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Index/LogMergePolicy.cs (original)
+++ lucene.net/trunk/src/core/Index/LogMergePolicy.cs Fri Oct  5 21:22:51 2012
@@ -27,8 +27,8 @@ namespace Lucene.Net.Index
 	/// the value of the merge factor. Whenever extra segments
 	/// (beyond the merge factor upper bound) are encountered,
 	/// all segments within the level are merged. You can get or
-	/// set the merge factor using <see cref="GetMergeFactor()" /> and
-	/// <see cref="SetMergeFactor(int)" /> respectively.<p/>
+	/// set the merge factor using <see cref="MergeFactor" /> and
+	/// <see cref="MergeFactor" /> respectively.<p/>
 	/// 
 	/// <p/>This class is abstract and requires a subclass to
 	/// define the <see cref="Size" /> method which specifies how a
@@ -55,13 +55,13 @@ namespace Lucene.Net.Index
 		public const int DEFAULT_MERGE_FACTOR = 10;
 		
 		/// <summary>Default maximum segment size.  A segment of this size</summary>
-		/// <seealso cref="SetMaxMergeDocs">
+		/// <seealso cref="MaxMergeDocs">
 		/// </seealso>
 		public static readonly int DEFAULT_MAX_MERGE_DOCS = System.Int32.MaxValue;
 
         /// <summary> Default noCFSRatio.  If a merge's size is >= 10% of
         ///  the index, then we disable compound file for it.
-        ///  See <see cref="SetNoCFSRatio"/>
+        ///  See <see cref="NoCFSRatio"/>
         ///  </summary>
         public static double DEFAULT_NO_CFS_RATIO = 0.1;
 		
@@ -101,7 +101,7 @@ namespace Lucene.Net.Index
 	        }
 	    }
 
-	    /** If a merged segment will be more than this percentage
+	    /* If a merged segment will be more than this percentage
          *  of the total size of the index, leave the segment as
          *  non-compound file even if compound file is enabled.
          *  Set to 1.0 to always use CFS regardless of merge
@@ -404,7 +404,7 @@ namespace Lucene.Net.Index
 		
 		/// <summary>Checks if any merges are now necessary and returns a
 		/// <see cref="MergePolicy.MergeSpecification" /> if so.  A merge
-		/// is necessary when there are more than <see cref="SetMergeFactor" />
+		/// is necessary when there are more than <see cref="MergeFactor" />
 		/// segments at a given level.  When
 		/// multiple levels have too many segments, this method
 		/// will return multiple merges, allowing the <see cref="MergeScheduler" />

Modified: lucene.net/trunk/src/core/Index/Payload.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Index/Payload.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Index/Payload.cs (original)
+++ lucene.net/trunk/src/core/Index/Payload.cs Fri Oct  5 21:22:51 2012
@@ -30,7 +30,7 @@ namespace Lucene.Net.Index
 	/// To store payloads in the index a <see cref="TokenStream"/> has to be used that
 	/// produces payload data.
 	/// <p/>
-    /// Use <see cref="TermPositions.GetPayloadLength()"/> and <see cref="TermPositions.GetPayload(byte[], int)"/>
+    /// Use <see cref="TermPositions.PayloadLength"/> and <see cref="TermPositions.GetPayload(byte[], int)"/>
 	/// to retrieve the payloads from the index.<br/>
 	/// 
 	/// </summary>

Modified: lucene.net/trunk/src/core/QueryParser/QueryParser.JJ
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/QueryParser/QueryParser.JJ?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/QueryParser/QueryParser.JJ (original)
+++ lucene.net/trunk/src/core/QueryParser/QueryParser.JJ Fri Oct  5 21:22:51 2012
@@ -1,4 +1,4 @@
-/**
+/*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
@@ -59,7 +59,7 @@ import org.apache.lucene.search.TermQuer
 import org.apache.lucene.search.WildcardQuery;
 import org.apache.lucene.util.Version;
 
-/**
+/*
  * This class is generated by JavaCC.  The most important method is
  * {@link #parse(String)}.
  *
@@ -67,7 +67,7 @@ import org.apache.lucene.util.Version;
  * A Query is a series of clauses.
  * A clause may be prefixed by:
  * <ul>
- * <li> a plus (<code>+</code>) or a minus (<code>-</code>) sign, indicating
+ * <li> a plus (<c>+</c>) or a minus (<c>-</c>) sign, indicating
  * that the clause is required or prohibited respectively; or
  * <li> a term followed by a colon, indicating the field to be searched.
  * This enables one to construct queries which search multiple fields.
@@ -77,7 +77,7 @@ import org.apache.lucene.util.Version;
  * <ul>
  * <li> a term, indicating all the documents that contain this term; or
  * <li> a nested query, enclosed in parentheses.  Note that this may be used
- * with a <code>+</code>/<code>-</code> prefix to require any of a set of
+ * with a <c>+</c>/<c>-</c> prefix to require any of a set of
  * terms.
  * </ul>
  *
@@ -145,12 +145,12 @@ public class QueryParser {
 
   // make it possible to call setDefaultOperator() without accessing 
   // the nested class:
-  /** Alternative form of QueryParser.Operator.AND */
+  /* Alternative form of QueryParser.Operator.AND */
   public static final Operator AND_OPERATOR = Operator.AND;
-  /** Alternative form of QueryParser.Operator.OR */
+  /* Alternative form of QueryParser.Operator.OR */
   public static final Operator OR_OPERATOR = Operator.OR;
 
-  /** The actual operator that parser uses to combine query terms */
+  /* The actual operator that parser uses to combine query terms */
   private Operator operator = OR_OPERATOR;
 
   boolean lowercaseExpandedTerms = true;
@@ -174,12 +174,12 @@ public class QueryParser {
   // for use when constructing RangeQuerys.
   Collator rangeCollator = null;
 
-  /** The default operator for parsing queries. 
+  /* The default operator for parsing queries. 
    * Use {@link QueryParser#setDefaultOperator} to change it.
    */
   static public enum Operator { OR, AND }
 
-  /** Constructs a query parser.
+  /* Constructs a query parser.
    *  @param matchVersion  Lucene version to match.  See {@link <a href="#version">above</a>)
    *  @param f  the default field for query terms.
    *  @param a   used to find terms in the query text.
@@ -195,7 +195,7 @@ public class QueryParser {
     }
   }
 
-  /** Parses a query string, returning a {@link org.apache.lucene.search.Query}.
+  /* Parses a query string, returning a {@link org.apache.lucene.search.Query}.
    *  @param query  the query string to be parsed.
    *  @throws ParseException if the parsing fails
    */
@@ -224,28 +224,28 @@ public class QueryParser {
     }
   }
 
-   /**
+   /*
    * @return Returns the analyzer.
    */
   public Analyzer getAnalyzer() {
     return analyzer;
   }
 
-  /**
+  /*
    * @return Returns the field.
    */
   public String getField() {
     return field;
   }
 
-   /**
+   /*
    * Get the minimal similarity for fuzzy queries.
    */
   public float getFuzzyMinSim() {
       return fuzzyMinSim;
   }
 
-  /**
+  /*
    * Set the minimum similarity for fuzzy queries.
    * Default is 0.5f.
    */
@@ -253,7 +253,7 @@ public class QueryParser {
       this.fuzzyMinSim = fuzzyMinSim;
   }
 
-   /**
+   /*
    * Get the prefix length for fuzzy queries. 
    * @return Returns the fuzzyPrefixLength.
    */
@@ -261,7 +261,7 @@ public class QueryParser {
     return fuzzyPrefixLength;
   }
 
-  /**
+  /*
    * Set the prefix length for fuzzy queries. Default is 0.
    * @param fuzzyPrefixLength The fuzzyPrefixLength to set.
    */
@@ -269,7 +269,7 @@ public class QueryParser {
     this.fuzzyPrefixLength = fuzzyPrefixLength;
   }
 
-  /**
+  /*
    * Sets the default slop for phrases.  If zero, then exact phrase matches
    * are required.  Default value is zero.
    */
@@ -277,7 +277,7 @@ public class QueryParser {
     this.phraseSlop = phraseSlop;
   }
 
-  /**
+  /*
    * Gets the default slop for phrases.
    */
   public int getPhraseSlop() {
@@ -285,10 +285,10 @@ public class QueryParser {
   }
 
 
-  /**
-   * Set to <code>true</code> to allow leading wildcard characters.
+  /*
+   * Set to <c>true</c> to allow leading wildcard characters.
    * <p>
-   * When set, <code>*</code> or <code>?</code> are allowed as 
+   * When set, <c>*</c> or <c>?</c> are allowed as 
    * the first character of a PrefixQuery and WildcardQuery.
    * Note that this can produce very slow
    * queries on big indexes. 
@@ -299,15 +299,15 @@ public class QueryParser {
     this.allowLeadingWildcard = allowLeadingWildcard;
   }
 
-  /**
+  /*
    * @see #setAllowLeadingWildcard(boolean)
    */
   public boolean getAllowLeadingWildcard() {
     return allowLeadingWildcard;
   }
 
-  /**
-   * Set to <code>true</code> to enable position increments in result query.
+  /*
+   * Set to <c>true</c> to enable position increments in result query.
    * <p>
    * When set, result phrase and multi-phrase queries will
    * be aware of position increments.
@@ -320,27 +320,27 @@ public class QueryParser {
     this.enablePositionIncrements = enable;
   }
 
-  /**
+  /*
    * @see #setEnablePositionIncrements(boolean)
    */
   public boolean getEnablePositionIncrements() {
     return enablePositionIncrements;
   }
 
-  /**
+  /*
    * Sets the boolean operator of the QueryParser.
-   * In default mode (<code>OR_OPERATOR</code>) terms without any modifiers
-   * are considered optional: for example <code>capital of Hungary</code> is equal to
-   * <code>capital OR of OR Hungary</code>.<br/>
-   * In <code>AND_OPERATOR</code> mode terms are considered to be in conjunction: the
-   * above mentioned query is parsed as <code>capital AND of AND Hungary</code>
+   * In default mode (<c>OR_OPERATOR</c>) terms without any modifiers
+   * are considered optional: for example <c>capital of Hungary</c> is equal to
+   * <c>capital OR of OR Hungary</c>.<br/>
+   * In <c>AND_OPERATOR</c> mode terms are considered to be in conjunction: the
+   * above mentioned query is parsed as <c>capital AND of AND Hungary</c>
    */
   public void setDefaultOperator(Operator op) {
     this.operator = op;
   }
 
 
-  /**
+  /*
    * Gets implicit operator setting, which will be either AND_OPERATOR
    * or OR_OPERATOR.
    */
@@ -349,23 +349,23 @@ public class QueryParser {
   }
 
 
-  /**
+  /*
    * Whether terms of wildcard, prefix, fuzzy and range queries are to be automatically
-   * lower-cased or not.  Default is <code>true</code>.
+   * lower-cased or not.  Default is <c>true</c>.
    */
   public void setLowercaseExpandedTerms(boolean lowercaseExpandedTerms) {
     this.lowercaseExpandedTerms = lowercaseExpandedTerms;
   }
 
 
-  /**
+  /*
    * @see #setLowercaseExpandedTerms(boolean)
    */
   public boolean getLowercaseExpandedTerms() {
     return lowercaseExpandedTerms;
   }
 
-  /**
+  /*
    * By default QueryParser uses {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}
    * when creating a PrefixQuery, WildcardQuery or RangeQuery. This implementation is generally preferable because it 
    * a) Runs faster b) Does not have the scarcity of terms unduly influence score 
@@ -380,28 +380,28 @@ public class QueryParser {
   }
 
 
-  /**
+  /*
    * @see #setMultiTermRewriteMethod
    */
   public MultiTermQuery.RewriteMethod getMultiTermRewriteMethod() {
     return multiTermRewriteMethod;
   }
 
-  /**
+  /*
    * Set locale used by date range parsing.
    */
   public void setLocale(Locale locale) {
     this.locale = locale;
   }
 
-  /**
+  /*
    * Returns current locale, allowing access by subclasses.
    */
   public Locale getLocale() {
     return locale;
   }
 
-  /**
+  /*
    * Sets the default date resolution used by RangeQueries for fields for which no
    * specific date resolutions has been set. Field specific resolutions can be set
    * with {@link #setDateResolution(String, DateTools.Resolution)}.
@@ -412,7 +412,7 @@ public class QueryParser {
     this.dateResolution = dateResolution;
   }
 
-  /**
+  /*
    * Sets the date resolution used by RangeQueries for a specific field.
    *  
    * @param fieldName field for which the date resolution is to be set 
@@ -431,7 +431,7 @@ public class QueryParser {
     fieldToDateResolution.put(fieldName, dateResolution);
   }
 
-  /**
+  /*
    * Returns the date resolution that is used by RangeQueries for the given field. 
    * Returns null, if no default or field specific date resolution has been set
    * for the given field.
@@ -456,7 +456,7 @@ public class QueryParser {
     return resolution;
   }
   
-  /** 
+  /* 
    * Sets the collator used to determine index term inclusion in ranges
    * for RangeQuerys.
    * <p/>
@@ -472,7 +472,7 @@ public class QueryParser {
     rangeCollator = rc;
   }
   
-  /**
+  /*
    * @return the collator used to determine index term inclusion in ranges
    * for RangeQuerys.
    */
@@ -531,7 +531,7 @@ public class QueryParser {
   }
 
 
-  /**
+  /*
    * @exception ParseException throw in overridden method to disallow
    */
   protected Query getFieldQuery(String field, String queryText)  throws ParseException {
@@ -705,7 +705,7 @@ public class QueryParser {
 
 
 
-  /**
+  /*
    * Base implementation delegates to {@link #getFieldQuery(String,String)}.
    * This method may be overridden, for example, to return
    * a SpanNearQuery instead of a PhraseQuery.
@@ -727,7 +727,7 @@ public class QueryParser {
   }
 
 
-  /**
+  /*
    * @exception ParseException throw in overridden method to disallow
    */
   protected Query getRangeQuery(String field,
@@ -773,7 +773,7 @@ public class QueryParser {
     return newRangeQuery(field, part1, part2, inclusive);
   }
 
- /**
+ /*
   * Builds a new BooleanQuery instance
   * @param disableCoord disable coord
   * @return new BooleanQuery instance
@@ -782,7 +782,7 @@ public class QueryParser {
     return new BooleanQuery(disableCoord); 
   }
 
- /**
+ /*
   * Builds a new BooleanClause instance
   * @param q sub query
   * @param occur how this clause should occur when matching documents
@@ -792,7 +792,7 @@ public class QueryParser {
     return new BooleanClause(q, occur);
   }
  
-  /**
+  /*
    * Builds a new TermQuery instance
    * @param term term
    * @return new TermQuery instance
@@ -801,7 +801,7 @@ public class QueryParser {
     return new TermQuery(term);
   }
  
-  /**
+  /*
    * Builds a new PhraseQuery instance
    * @return new PhraseQuery instance
    */
@@ -809,7 +809,7 @@ public class QueryParser {
     return new PhraseQuery();
   }
  
-  /**
+  /*
    * Builds a new MultiPhraseQuery instance
    * @return new MultiPhraseQuery instance
    */
@@ -817,7 +817,7 @@ public class QueryParser {
     return new MultiPhraseQuery();
   }
  
-  /**
+  /*
    * Builds a new PrefixQuery instance
    * @param prefix Prefix term
    * @return new PrefixQuery instance
@@ -828,7 +828,7 @@ public class QueryParser {
     return query;
   }
  
-  /**
+  /*
    * Builds a new FuzzyQuery instance
    * @param term Term
    * @param minimumSimilarity minimum similarity
@@ -840,7 +840,7 @@ public class QueryParser {
     return new FuzzyQuery(term,minimumSimilarity,prefixLength);
   }
 
-  /**
+  /*
    * Builds a new TermRangeQuery instance
    * @param field Field
    * @param part1 min
@@ -854,7 +854,7 @@ public class QueryParser {
     return query;
   }
   
-  /**
+  /*
    * Builds a new MatchAllDocsQuery instance
    * @return new MatchAllDocsQuery instance
    */
@@ -862,7 +862,7 @@ public class QueryParser {
     return new MatchAllDocsQuery(); 
   }
 
-  /**
+  /*
    * Builds a new WildcardQuery instance
    * @param t wildcard term
    * @return new WildcardQuery instance
@@ -873,7 +873,7 @@ public class QueryParser {
     return query;
   }
 
-  /**
+  /*
    * Factory method for generating query, given a set of clauses.
    * By default creates a boolean query composed of clauses passed in.
    *
@@ -890,7 +890,7 @@ public class QueryParser {
     return getBooleanQuery(clauses, false);
   }
 
-  /**
+  /*
    * Factory method for generating query, given a set of clauses.
    * By default creates a boolean query composed of clauses passed in.
    *
@@ -917,7 +917,7 @@ public class QueryParser {
     return query;
   }
 
-  /**
+  /*
    * Factory method for generating a query. Called when parser
    * parses an input term token that contains one or more wildcard
    * characters (? and *), but is not a prefix term token (one
@@ -952,7 +952,7 @@ public class QueryParser {
     return newWildcardQuery(t);
   }
 
-  /**
+  /*
    * Factory method for generating a query (similar to
    * {@link #getWildcardQuery}). Called when parser parses an input term
    * token that uses prefix notation; that is, contains a single '*' wildcard
@@ -986,7 +986,7 @@ public class QueryParser {
     return newPrefixQuery(t);
   }
 
-   /**
+   /*
    * Factory method for generating a query (similar to
    * {@link #getWildcardQuery}). Called when parser parses
    * an input term token that has the fuzzy suffix (~) appended.
@@ -1006,12 +1006,12 @@ public class QueryParser {
     return newFuzzyQuery(t, minSimilarity, fuzzyPrefixLength);
   }
 
-  /**
+  /*
    * Returns a String where the escape char has been
    * removed, or kept only once if there was a double escape.
    * 
    * Supports escaped unicode characters, e. g. translates
-   * <code>\\u0041</code> to <code>A</code>.
+   * <c>\\u0041</c> to <c>A</c>.
    * 
    */
   private String discardEscapeChar(String input) throws ParseException {
@@ -1074,7 +1074,7 @@ public class QueryParser {
     return new String(output, 0, length);
   }
 
-  /** Returns the numeric value of the hexadecimal character */
+  /* Returns the numeric value of the hexadecimal character */
   private static final int hexToInt(char c) throws ParseException {
     if ('0' <= c && c <= '9') {
       return c - '0';
@@ -1087,9 +1087,9 @@ public class QueryParser {
     }
   }
 
-  /**
+  /*
    * Returns a String where those characters that QueryParser
-   * expects to be escaped are escaped by a preceding <code>\</code>.
+   * expects to be escaped are escaped by a preceding <c>\</c>.
    */
   public static String escape(String s) {
     StringBuilder sb = new StringBuilder();
@@ -1106,10 +1106,10 @@ public class QueryParser {
     return sb.toString();
   }
 
-  /**
+  /*
    * Command line tool to test QueryParser, using {@link org.apache.lucene.analysis.SimpleAnalyzer}.
    * Usage:<br>
-   * <code>java org.apache.lucene.queryParser.QueryParser &lt;input&gt;</code>
+   * <c>java org.apache.lucene.queryParser.QueryParser &lt;input&gt;</c>
    */
   public static void main(String[] args) throws Exception {
     if (args.length == 0) {

Modified: lucene.net/trunk/src/core/QueryParser/QueryParser.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/QueryParser/QueryParser.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/QueryParser/QueryParser.cs (original)
+++ lucene.net/trunk/src/core/QueryParser/QueryParser.cs Fri Oct  5 21:22:51 2012
@@ -90,7 +90,7 @@ namespace Lucene.Net.QueryParsers
     /// In <see cref="TermRangeQuery" />s, QueryParser tries to detect date values, e.g.
     /// <tt>date:[6/1/2005 TO 6/4/2005]</tt> produces a range query that searches
     /// for "date" fields between 2005-06-01 and 2005-06-04. Note that the format
-    /// of the accepted input depends on <see cref="SetLocale(System.Globalization.CultureInfo)">the locale</see>.
+    /// of the accepted input depends on the <see cref="Locale" />.
     /// By default a date is converted into a search term using the deprecated
     /// <see cref="DateField" /> for compatibility reasons.
     /// To use the new <see cref="DateTools" /> to convert dates, a
@@ -173,7 +173,7 @@ namespace Lucene.Net.QueryParsers
         // for use when constructing RangeQuerys.
         private System.Globalization.CompareInfo rangeCollator = null;
 
-        /** The default operator_Renamed for parsing queries. 
+        /* The default operator_Renamed for parsing queries. 
          * Use {@link QueryParser#setDefaultOperator} to change it.
          */
 
@@ -183,7 +183,7 @@ namespace Lucene.Net.QueryParsers
             AND
         }
 
-        /** Constructs a query parser.
+        /* Constructs a query parser.
          *  @param matchVersion  Lucene version to match.  See <a href="#version">above</a>)
          *  @param f  the default field for query terms.
          *  @param a   used to find terms in the query text.
@@ -292,7 +292,7 @@ namespace Lucene.Net.QueryParsers
             get { return allowLeadingWildcard; }
         }
 
-        /// <summary>Set to <code>true</code> to enable position increments in result query.
+        /// <summary>Set to <c>true</c> to enable position increments in result query.
         /// <p/>
         /// When set, result phrase and multi-phrase queries will
         /// be aware of position increments.
@@ -1069,7 +1069,7 @@ namespace Lucene.Net.QueryParsers
         /// removed, or kept only once if there was a double escape.
         /// 
         /// Supports escaped unicode characters, e. g. translates
-        /// <code>\\u0041</code> to <code>A</code>.
+        /// <c>\\u0041</c> to <c>A</c>.
         /// 
         /// </summary>
         private String DiscardEscapeChar(String input)
@@ -1170,7 +1170,7 @@ namespace Lucene.Net.QueryParsers
         }
 
         /// <summary> Returns a String where those characters that QueryParser
-        /// expects to be escaped are escaped by a preceding <code>\</code>.
+        /// expects to be escaped are escaped by a preceding <c>\</c>.
         /// </summary>
         public static String Escape(String s)
         {
@@ -1192,7 +1192,7 @@ namespace Lucene.Net.QueryParsers
 
         /// <summary> Command line tool to test QueryParser, using {@link Lucene.Net.Analysis.SimpleAnalyzer}.
         /// Usage:<br/>
-        /// <code>java Lucene.Net.QueryParsers.QueryParser &lt;input&gt;</code>
+        /// <c>java Lucene.Net.QueryParsers.QueryParser &lt;input&gt;</c>
         /// </summary>
         [STAThread]
         public static void Main(String[] args)
@@ -1751,11 +1751,11 @@ namespace Lucene.Net.QueryParsers
             return false;
         }
 
-        /** Generated Token Manager. */
+        /* Generated Token Manager. */
         public QueryParserTokenManager token_source;
-        /** Current token. */
+        /* Current token. */
         public Token token;
-        /** Next token. */
+        /* Next token. */
         public Token jj_nt;
         private int jj_ntk;
         private Token jj_scanpos, jj_lastpos;

Modified: lucene.net/trunk/src/core/Search/BooleanQuery.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/BooleanQuery.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/BooleanQuery.cs (original)
+++ lucene.net/trunk/src/core/Search/BooleanQuery.cs Fri Oct  5 21:22:51 2012
@@ -61,7 +61,7 @@ namespace Lucene.Net.Search
 		
 		private static int _maxClauses = 1024;
 		
-		/// <summary>Thrown when an attempt is made to add more than <see cref="GetMaxClauseCount()" />
+		/// <summary>Thrown when an attempt is made to add more than <see cref="MaxClauseCount" />
 		/// clauses. This typically happens if
 		/// a PrefixQuery, FuzzyQuery, WildcardQuery, or TermRangeQuery 
 		/// is expanded to many terms during search. 
@@ -166,7 +166,7 @@ namespace Lucene.Net.Search
 		/// 
 		/// </summary>
 		/// <throws>  TooManyClauses if the new number of clauses exceeds the maximum clause number </throws>
-		/// <seealso cref="GetMaxClauseCount()">
+		/// <seealso cref="MaxClauseCount">
 		/// </seealso>
 		public virtual void  Add(Query query, Occur occur)
 		{
@@ -175,7 +175,7 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Adds a clause to a boolean query.</summary>
 		/// <throws>  TooManyClauses if the new number of clauses exceeds the maximum clause number </throws>
-		/// <seealso cref="GetMaxClauseCount()">
+		/// <seealso cref="MaxClauseCount">
 		/// </seealso>
 		public virtual void  Add(BooleanClause clause)
 		{

Modified: lucene.net/trunk/src/core/Search/CachingWrapperFilter.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/CachingWrapperFilter.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/CachingWrapperFilter.cs (original)
+++ lucene.net/trunk/src/core/Search/CachingWrapperFilter.cs Fri Oct  5 21:22:51 2012
@@ -62,7 +62,7 @@ namespace Lucene.Net.Search
         [Serializable]
         abstract internal class FilterCache<T> where T : class
         {
-            /**
+            /*
              * A transient Filter cache (package private because of test)
              */
             // NOTE: not final so that we can dynamically re-init

Modified: lucene.net/trunk/src/core/Search/Collector.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/Collector.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/Collector.cs (original)
+++ lucene.net/trunk/src/core/Search/Collector.cs Fri Oct  5 21:22:51 2012
@@ -28,24 +28,24 @@ namespace Lucene.Net.Search
 	/// 
 	/// <p/>Lucene's core collectors are derived from Collector.
 	/// Likely your application can use one of these classes, or
-	/// subclass <see cref="TopDocsCollector" />, instead of
+	/// subclass <see cref="TopDocsCollector{T}" />, instead of
 	/// implementing Collector directly:
 	/// 
 	/// <list type="bullet">
 	/// 
-	/// <item><see cref="TopDocsCollector" /> is an abstract base class
+    /// <item><see cref="TopDocsCollector{T}" /> is an abstract base class
 	/// that assumes you will retrieve the top N docs,
 	/// according to some criteria, after collection is
 	/// done.  </item>
 	/// 
 	/// <item><see cref="TopScoreDocCollector" /> is a concrete subclass
-	/// <see cref="TopDocsCollector" /> and sorts according to score +
+    /// <see cref="TopDocsCollector{T}" /> and sorts according to score +
 	/// docID.  This is used internally by the <see cref="IndexSearcher" />
 	/// search methods that do not take an
 	/// explicit <see cref="Sort" />. It is likely the most frequently
 	/// used collector.</item>
 	/// 
-	/// <item><see cref="TopFieldCollector" /> subclasses <see cref="TopDocsCollector" />
+    /// <item><see cref="TopFieldCollector" /> subclasses <see cref="TopDocsCollector{T}" />
 	/// and sorts according to a specified
 	/// <see cref="Sort" /> object (sort by field).  This is used
 	/// internally by the <see cref="IndexSearcher" /> search methods

Modified: lucene.net/trunk/src/core/Search/DefaultSimilarity.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/DefaultSimilarity.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/DefaultSimilarity.cs (original)
+++ lucene.net/trunk/src/core/Search/DefaultSimilarity.cs Fri Oct  5 21:22:51 2012
@@ -29,9 +29,9 @@ namespace Lucene.Net.Search
 		
 		/// <summary>Implemented as
 		/// <c>state.getBoost()*lengthNorm(numTerms)</c>, where
-		/// <c>numTerms</c> is <see cref="FieldInvertState.GetLength()" /> if <see cref="SetDiscountOverlaps" />
-		/// is false, else it's <see cref="FieldInvertState.GetLength()" />
-		/// - <see cref="FieldInvertState.GetNumOverlap()" />
+		/// <c>numTerms</c> is <see cref="FieldInvertState.Length" /> if <see cref="DiscountOverlaps" />
+		/// is false, else it's <see cref="FieldInvertState.Length" />
+		/// - <see cref="FieldInvertState.NumOverlap" />
 		///.
 		/// 
 		/// <p/><b>WARNING</b>: This API is new and experimental, and may suddenly
@@ -83,7 +83,7 @@ namespace Lucene.Net.Search
 			return overlap / (float) maxOverlap;
 		}
 
-	    /// <seealso cref="SetDiscountOverlaps">
+	    /// <seealso cref="DiscountOverlaps">
         /// </seealso>
         // Default false
         protected internal bool internalDiscountOverlaps;

Modified: lucene.net/trunk/src/core/Search/DisjunctionMaxScorer.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/DisjunctionMaxScorer.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/DisjunctionMaxScorer.cs (original)
+++ lucene.net/trunk/src/core/Search/DisjunctionMaxScorer.cs Fri Oct  5 21:22:51 2012
@@ -90,7 +90,7 @@ namespace Lucene.Net.Search
 			return doc;
 		}
 		
-		/// <summary>Determine the current document score.  Initially invalid, until <see cref="Next()" /> is called the first time.</summary>
+		/// <summary>Determine the current document score.  Initially invalid, until <see cref="NextDoc()" /> is called the first time.</summary>
 		/// <returns> the score of the current generated document
 		/// </returns>
 		public override float Score()

Modified: lucene.net/trunk/src/core/Search/DisjunctionSumScorer.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/DisjunctionSumScorer.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/DisjunctionSumScorer.cs (original)
+++ lucene.net/trunk/src/core/Search/DisjunctionSumScorer.cs Fri Oct  5 21:22:51 2012
@@ -23,7 +23,7 @@ namespace Lucene.Net.Search
 {
 	
 	/// <summary>A Scorer for OR like queries, counterpart of <c>ConjunctionScorer</c>.
-	/// This Scorer implements <see cref="DocIdSetIterator.SkipTo(int)" /> and uses skipTo() on the given Scorers.
+	/// This Scorer implements <see cref="DocIdSetIterator.Advance(int)" /> and uses skipTo() on the given Scorers.
 	/// </summary>
 	class DisjunctionSumScorer:Scorer
 	{
@@ -114,9 +114,7 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Scores and collects all matching documents.</summary>
-		/// <param name="collector">The collector to which all matching documents are passed through.
-		/// <br/>When this method is used the <see cref="Explain(int)" /> method should not be used.
-		/// </param>
+		/// <param name="collector">The collector to which all matching documents are passed through.</param>
 		public override void  Score(Collector collector)
 		{
 			collector.SetScorer(this);
@@ -127,7 +125,7 @@ namespace Lucene.Net.Search
 		}
 
 	    /// <summary>Expert: Collects matching documents in a range.  Hook for optimization.
-	    /// Note that <see cref="Next()" /> must be called once before this method is called
+	    /// Note that <see cref="NextDoc()" /> must be called once before this method is called
 	    /// for the first time.
 	    /// </summary>
 	    /// <param name="collector">The collector to which all matching documents are passed through.
@@ -220,7 +218,7 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Returns the score of the current document matching the query.
-		/// Initially invalid, until <see cref="Next()" /> is called the first time.
+		/// Initially invalid, until <see cref="NextDoc()" /> is called the first time.
 		/// </summary>
 		public override float Score()
 		{
@@ -233,7 +231,7 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Returns the number of subscorers matching the current document.
-		/// Initially invalid, until <see cref="Next()" /> is called the first time.
+		/// Initially invalid, until <see cref="NextDoc()" /> is called the first time.
 		/// </summary>
 		public virtual int NrMatchers()
 		{

Modified: lucene.net/trunk/src/core/Search/Explanation.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/Explanation.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/Explanation.cs (original)
+++ lucene.net/trunk/src/core/Search/Explanation.cs Fri Oct  5 21:22:51 2012
@@ -45,7 +45,7 @@ namespace Lucene.Net.Search
 	    /// By default, an Explanation represents a "match" if the value is positive.
 	    /// <p/>
 	    /// </summary>
-	    /// <seealso cref="GetValue">
+	    /// <seealso cref="Value">
 	    /// </seealso>
 	    public virtual bool IsMatch
 	    {

Modified: lucene.net/trunk/src/core/Search/FieldCacheImpl.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/FieldCacheImpl.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/FieldCacheImpl.cs (original)
+++ lucene.net/trunk/src/core/Search/FieldCacheImpl.cs Fri Oct  5 21:22:51 2012
@@ -194,7 +194,7 @@ namespace Lucene.Net.Search
             
             protected internal abstract System.Object CreateValue(IndexReader reader, Entry key);
 
-            /** Remove this reader from the cache, if present. */
+            /* Remove this reader from the cache, if present. */
             public void Purge(IndexReader r)
             {
                 object readerKey = r.FieldCacheKey;

Modified: lucene.net/trunk/src/core/Search/FieldComparator.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/FieldComparator.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/FieldComparator.cs (original)
+++ lucene.net/trunk/src/core/Search/FieldComparator.cs Fri Oct  5 21:22:51 2012
@@ -71,7 +71,7 @@ namespace Lucene.Net.Search
 	/// comparator, for example retrieving new values from
 	/// the <see cref="FieldCache" />.</item>
 	/// 
-	/// <item> <see cref="Value" /> Return the sort value stored in
+    /// <item> <see cref="P:Lucene.Net.Search.FieldComparator.Item(System.Int32)" /> Return the sort value stored in
 	/// the specified slot.  This is only called at the end
 	/// of the search, in order to populate <see cref="FieldDoc.fields" />
 	/// when returning the top results.</item>
@@ -582,7 +582,7 @@ namespace Lucene.Net.Search
 		/// <summary>Sorts by descending relevance.  NOTE: if you are
 		/// sorting only by descending relevance and then
 		/// secondarily by ascending docID, peformance is faster
-		/// using <see cref="TopScoreDocCollector" /> directly (which <see cref="Searcher.Search(Query)" />
+		/// using <see cref="TopScoreDocCollector" /> directly (which <see cref="Searcher.Search(Query, int)" />
 		/// uses when no <see cref="Sort" /> is
 		/// specified). 
 		/// </summary>

Modified: lucene.net/trunk/src/core/Search/FieldValueHitQueue.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/FieldValueHitQueue.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/FieldValueHitQueue.cs (original)
+++ lucene.net/trunk/src/core/Search/FieldValueHitQueue.cs Fri Oct  5 21:22:51 2012
@@ -78,12 +78,9 @@ namespace Lucene.Net.Search
 			}
 			
 			/// <summary> Returns whether <c>a</c> is less relevant than <c>b</c>.</summary>
-			/// <param name="a">ScoreDoc
-			/// </param>
-			/// <param name="b">ScoreDoc
-			/// </param>
-			/// <returns> <c>true</c> if document <c>a</c> should be sorted after document <c>b</c>.
-			/// </returns>
+			/// <param name="hitA">ScoreDoc</param>
+			/// <param name="hitB">ScoreDoc</param>
+			/// <returns><c>true</c> if document <c>a</c> should be sorted after document <c>b</c>.</returns>
             public override bool LessThan(Entry hitA, Entry hitB)
 			{
 				System.Diagnostics.Debug.Assert(hitA != hitB);

Modified: lucene.net/trunk/src/core/Search/Function/ByteFieldSource.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/Function/ByteFieldSource.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/Function/ByteFieldSource.cs (original)
+++ lucene.net/trunk/src/core/Search/Function/ByteFieldSource.cs Fri Oct  5 21:22:51 2012
@@ -42,10 +42,7 @@ namespace Lucene.Net.Search.Function
 	/// composite (multi-segment) reader, this can easily cause
 	/// double RAM usage for the values in the FieldCache.  It's
 	/// best to switch your application to pass only atomic
-	/// (single segment) readers to this API.  Alternatively, for
-	/// a short-term fix, you could wrap your ValueSource using
-	/// <see cref="MultiValueSource" />, which costs more CPU per lookup
-	/// but will not consume double the FieldCache RAM.<p/>
+	/// (single segment) readers to this API.<p/>
 	/// </seealso>
 	[Serializable]
 	public class ByteFieldSource:FieldCacheSource

Modified: lucene.net/trunk/src/core/Search/Function/FloatFieldSource.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/Function/FloatFieldSource.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/Function/FloatFieldSource.cs (original)
+++ lucene.net/trunk/src/core/Search/Function/FloatFieldSource.cs Fri Oct  5 21:22:51 2012
@@ -42,10 +42,7 @@ namespace Lucene.Net.Search.Function
 	/// composite (multi-segment) reader, this can easily cause
 	/// double RAM usage for the values in the FieldCache.  It's
 	/// best to switch your application to pass only atomic
-	/// (single segment) readers to this API.  Alternatively, for
-	/// a short-term fix, you could wrap your ValueSource using
-	/// <see cref="MultiValueSource" />, which costs more CPU per lookup
-	/// but will not consume double the FieldCache RAM.<p/>
+	/// (single segment) readers to this API.<p/>
 	/// </seealso>
 	[Serializable]
 	public class FloatFieldSource:FieldCacheSource

Modified: lucene.net/trunk/src/core/Search/Function/IntFieldSource.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/Function/IntFieldSource.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/Function/IntFieldSource.cs (original)
+++ lucene.net/trunk/src/core/Search/Function/IntFieldSource.cs Fri Oct  5 21:22:51 2012
@@ -42,10 +42,7 @@ namespace Lucene.Net.Search.Function
 	/// composite (multi-segment) reader, this can easily cause
 	/// double RAM usage for the values in the FieldCache.  It's
 	/// best to switch your application to pass only atomic
-	/// (single segment) readers to this API.  Alternatively, for
-	/// a short-term fix, you could wrap your ValueSource using
-	/// <see cref="MultiValueSource" />, which costs more CPU per lookup
-	/// but will not consume double the FieldCache RAM.<p/>
+	/// (single segment) readers to this API.<p/>
 	/// </seealso>
 	[Serializable]
 	public class IntFieldSource:FieldCacheSource

Modified: lucene.net/trunk/src/core/Search/Function/ShortFieldSource.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/Function/ShortFieldSource.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/Function/ShortFieldSource.cs (original)
+++ lucene.net/trunk/src/core/Search/Function/ShortFieldSource.cs Fri Oct  5 21:22:51 2012
@@ -42,10 +42,7 @@ namespace Lucene.Net.Search.Function
 	/// composite (multi-segment) reader, this can easily cause
 	/// double RAM usage for the values in the FieldCache.  It's
 	/// best to switch your application to pass only atomic
-	/// (single segment) readers to this API.  Alternatively, for
-	/// a short-term fix, you could wrap your ValueSource using
-	/// <see cref="MultiValueSource" />, which costs more CPU per lookup
-	/// but will not consume double the FieldCache RAM.<p/>
+	/// (single segment) readers to this API.<p/>
 	/// </seealso>
 	[Serializable]
 	public class ShortFieldSource:FieldCacheSource

Modified: lucene.net/trunk/src/core/Search/HitQueue.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/HitQueue.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/HitQueue.cs (original)
+++ lucene.net/trunk/src/core/Search/HitQueue.cs Fri Oct  5 21:22:51 2012
@@ -28,8 +28,8 @@ namespace Lucene.Net.Search
 		
 		/// <summary> Creates a new instance with <c>size</c> elements. If
 		/// <c>prePopulate</c> is set to true, the queue will pre-populate itself
-        /// with sentinel objects and set its <see cref="PriorityQueue.Size()" /> to <c>size</c>. In
-        /// that case, you should not rely on <see cref="PriorityQueue.Size()" /> to get the number of
+        /// with sentinel objects and set its <see cref="PriorityQueue{T}.Size()" /> to <c>size</c>. In
+        /// that case, you should not rely on <see cref="PriorityQueue{T}.Size()" /> to get the number of
 		/// actual elements that were added to the queue, but keep track yourself.<br/>
 		/// <b>NOTE:</b> in case <c>prePopulate</c> is true, you should pop
 		/// elements from the queue using the following code example:
@@ -63,7 +63,7 @@ namespace Lucene.Net.Search
 		/// </param>
 		/// <param name="prePopulate">specifies whether to pre-populate the queue with sentinel values.
 		/// </param>
-		/// <seealso cref="GetSentinelObject()">
+		/// <seealso cref="SentinelObject">
 		/// </seealso>
 		public /*internal*/ HitQueue(int size, bool prePopulate)
 		{

Modified: lucene.net/trunk/src/core/Search/IndexSearcher.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/IndexSearcher.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/IndexSearcher.cs (original)
+++ lucene.net/trunk/src/core/Search/IndexSearcher.cs Fri Oct  5 21:22:51 2012
@@ -31,8 +31,8 @@ namespace Lucene.Net.Search
 	
 	/// <summary>Implements search over a single IndexReader.
 	/// 
-	/// <p/>Applications usually need only call the inherited <see cref="Searcher.Search(Query)" />
-	/// or <see cref="Searcher.Search(Query,Filter)" /> methods. For performance reasons it is 
+	/// <p/>Applications usually need only call the inherited <see cref="Searcher.Search(Query,int)" />
+	/// or <see cref="Searcher.Search(Query,Filter,int)" /> methods. For performance reasons it is 
 	/// recommended to open only one IndexSearcher and use it for all of your searches.
 	/// 
 	/// <a name="thread-safety"></a><p/><b>NOTE</b>:

Modified: lucene.net/trunk/src/core/Search/MultiPhraseQuery.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/MultiPhraseQuery.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/MultiPhraseQuery.cs (original)
+++ lucene.net/trunk/src/core/Search/MultiPhraseQuery.cs Fri Oct  5 21:22:51 2012
@@ -46,7 +46,7 @@ namespace Lucene.Net.Search
 		private int slop = 0;
 
 	    /// <summary>Gets or sets the phrase slop for this query.</summary>
-	    /// <seealso cref="PhraseQuery.SetSlop(int)">
+	    /// <seealso cref="PhraseQuery.Slop">
 	    /// </seealso>
 	    public virtual int Slop
 	    {

Modified: lucene.net/trunk/src/core/Search/MultiTermQuery.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/MultiTermQuery.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/MultiTermQuery.cs (original)
+++ lucene.net/trunk/src/core/Search/MultiTermQuery.cs Fri Oct  5 21:22:51 2012
@@ -35,13 +35,13 @@ namespace Lucene.Net.Search
 	/// that iterates through the terms to be
 	/// matched.
 	/// 
-	/// <p/><b>NOTE</b>: if <see cref="SetRewriteMethod" /> is either
+	/// <p/><b>NOTE</b>: if <see cref="RewriteMethod" /> is either
 	/// <see cref="CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE" /> or <see cref="SCORING_BOOLEAN_QUERY_REWRITE" />
 	///, you may encounter a
 	/// <see cref="BooleanQuery.TooManyClauses" /> exception during
 	/// searching, which happens when the number of terms to be
-	/// searched exceeds <see cref="BooleanQuery.GetMaxClauseCount()" />
-	///.  Setting <see cref="SetRewriteMethod" />
+	/// searched exceeds <see cref="BooleanQuery.MaxClauseCount" />
+	///.  Setting <see cref="RewriteMethod" />
 	/// to <see cref="CONSTANT_SCORE_FILTER_REWRITE" />
 	/// prevents this.
 	/// 
@@ -109,7 +109,7 @@ namespace Lucene.Net.Search
 		/// exception.
 		/// 
 		/// </summary>
-		/// <seealso cref="SetRewriteMethod">
+		/// <seealso cref="RewriteMethod">
 		/// </seealso>
 		public static readonly RewriteMethod CONSTANT_SCORE_FILTER_REWRITE = new ConstantScoreFilterRewrite();
 		
@@ -162,10 +162,10 @@ namespace Lucene.Net.Search
 		/// 
 		/// <p/><b>NOTE</b>: This rewrite method will hit <see cref="BooleanQuery.TooManyClauses" />
 		/// if the number of terms
-		/// exceeds <see cref="BooleanQuery.GetMaxClauseCount" />.
+		/// exceeds <see cref="BooleanQuery.MaxClauseCount" />.
 		/// 
 		/// </summary>
-		/// <seealso cref="SetRewriteMethod">
+		/// <seealso cref="RewriteMethod">
 		/// </seealso>
 		public static readonly RewriteMethod SCORING_BOOLEAN_QUERY_REWRITE = new ScoringBooleanQueryRewrite();
 		
@@ -194,10 +194,10 @@ namespace Lucene.Net.Search
 		/// 
 		/// <p/><b>NOTE</b>: This rewrite method will hit <see cref="BooleanQuery.TooManyClauses" />
 		/// if the number of terms
-		/// exceeds <see cref="BooleanQuery.GetMaxClauseCount" />.
+		/// exceeds <see cref="BooleanQuery.MaxClauseCount" />.
 		/// 
 		/// </summary>
-		/// <seealso cref="SetRewriteMethod">
+		/// <seealso cref="RewriteMethod">
 		/// </seealso>
 		public static readonly RewriteMethod CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE = new ConstantScoreBooleanQueryRewrite();
 		
@@ -347,11 +347,11 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Read-only default instance of <see cref="ConstantScoreAutoRewrite" />
-		///, with <see cref="ConstantScoreAutoRewrite.SetTermCountCutoff" />
+		///, with <see cref="ConstantScoreAutoRewrite.TermCountCutoff" />
 		/// set to
 		/// <see cref="ConstantScoreAutoRewrite.DEFAULT_TERM_COUNT_CUTOFF" />
 		///
-		/// and <see cref="ConstantScoreAutoRewrite.SetDocCountPercent" />
+		/// and <see cref="ConstantScoreAutoRewrite.DocCountPercent" />
 		/// set to
 		/// <see cref="ConstantScoreAutoRewrite.DEFAULT_DOC_COUNT_PERCENT" />
 		///.

Modified: lucene.net/trunk/src/core/Search/MultiTermQueryWrapperFilter.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/MultiTermQueryWrapperFilter.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/MultiTermQueryWrapperFilter.cs (original)
+++ lucene.net/trunk/src/core/Search/MultiTermQueryWrapperFilter.cs Fri Oct  5 21:22:51 2012
@@ -96,7 +96,7 @@ namespace Lucene.Net.Search
 	    /// <summary> Expert: Resets the counting of unique terms.
 		/// Do this before executing the filter.
 		/// </summary>
-		/// <seealso cref="GetTotalNumberOfTerms">
+		/// <seealso cref="TotalNumberOfTerms">
 		/// </seealso>
 		public virtual void  ClearTotalNumberOfTerms()
 		{

Modified: lucene.net/trunk/src/core/Search/PhraseQuery.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/PhraseQuery.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/PhraseQuery.cs (original)
+++ lucene.net/trunk/src/core/Search/PhraseQuery.cs Fri Oct  5 21:22:51 2012
@@ -290,7 +290,7 @@ namespace Lucene.Net.Search
 			return new PhraseWeight(this, searcher);
 		}
 		
-		/// <seealso cref="Lucene.Net.Search.Query.ExtractTerms(System.Collections.Generic.ISet{T})">
+		/// <seealso cref="Lucene.Net.Search.Query.ExtractTerms(System.Collections.Generic.ISet{Term})">
 		/// </seealso>
 		public override void ExtractTerms(System.Collections.Generic.ISet<Term> queryTerms)
 		{

Modified: lucene.net/trunk/src/core/Search/ReqOptSumScorer.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/ReqOptSumScorer.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/ReqOptSumScorer.cs (original)
+++ lucene.net/trunk/src/core/Search/ReqOptSumScorer.cs Fri Oct  5 21:22:51 2012
@@ -23,7 +23,7 @@ namespace Lucene.Net.Search
 	/// <summary>A Scorer for queries with a required part and an optional part.
 	/// Delays skipTo() on the optional part until a score() is needed.
 	/// <br/>
-	/// This <c>Scorer</c> implements <see cref="DocIdSetIterator.SkipTo(int)" />.
+	/// This <c>Scorer</c> implements <see cref="DocIdSetIterator.Advance(int)" />.
 	/// </summary>
 	class ReqOptSumScorer:Scorer
 	{
@@ -60,7 +60,7 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Returns the score of the current document matching the query.
-		/// Initially invalid, until <see cref="Next()" /> is called the first time.
+		/// Initially invalid, until <see cref="NextDoc()" /> is called the first time.
 		/// </summary>
 		/// <returns> The score of the required scorer, eventually increased by the score
 		/// of the optional scorer when it also matches the current document.

Modified: lucene.net/trunk/src/core/Search/Searchable.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/Searchable.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/Searchable.cs (original)
+++ lucene.net/trunk/src/core/Search/Searchable.cs Fri Oct  5 21:22:51 2012
@@ -90,22 +90,18 @@ namespace Lucene.Net.Search
 	    /// </seealso>
 	    int MaxDoc { get; }
 		
-		/// <summary>Expert: Low-level search implementation.  Finds the top <c>n</c>
+		/// <summary>
+		/// Expert: Low-level search implementation.  Finds the top <c>n</c>
 		/// hits for <c>query</c>, applying <c>filter</c> if non-null.
 		/// 
-		/// <p/>Called by <see cref="Hits" />.
-		/// 
 		/// <p/>Applications should usually call <see cref="Searcher.Search(Query, int)" /> or
 		/// <see cref="Searcher.Search(Query,Filter,int)" /> instead.
 		/// </summary>
 		/// <throws>  BooleanQuery.TooManyClauses </throws>
 		TopDocs Search(Weight weight, Filter filter, int n);
 		
-		/// <summary>Expert: Returns the stored fields of document <c>i</c>.
-		/// Called by <see cref="HitCollector" /> implementations.
-		/// </summary>
-		/// <seealso cref="Lucene.Net.Index.IndexReader.Document(int)">
-		/// </seealso>
+		/// <summary>Expert: Returns the stored fields of document <c>i</c>.</summary>
+		/// <seealso cref="Lucene.Net.Index.IndexReader.Document(int)" />
 		/// <throws>  CorruptIndexException if the index is corrupt </throws>
 		/// <throws>  IOException if there is a low-level IO error </throws>
 		Document Doc(int i);

Modified: lucene.net/trunk/src/core/Search/Searcher.cs
URL: http://svn.apache.org/viewvc/lucene.net/trunk/src/core/Search/Searcher.cs?rev=1394820&r1=1394819&r2=1394820&view=diff
==============================================================================
--- lucene.net/trunk/src/core/Search/Searcher.cs (original)
+++ lucene.net/trunk/src/core/Search/Searcher.cs Fri Oct  5 21:22:51 2012
@@ -137,7 +137,7 @@ namespace Lucene.Net.Search
 	    /// <summary>Expert: Gets or Sets the Similarity implementation used by this Searcher.
 	    /// 
 	    /// </summary>
-	    /// <seealso cref="Similarity.SetDefault(Similarity)">
+	    /// <seealso cref="Lucene.Net.Search.Similarity.Default">
 	    /// </seealso>
 	    public virtual Similarity Similarity
 	    {



Mime
View raw message