lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ccurr...@apache.org
Subject [Lucene.Net] svn commit: r1198132 [15/17] - in /incubator/lucene.net/trunk/src: contrib/Analyzers/AR/ contrib/Analyzers/BR/ contrib/Analyzers/CJK/ contrib/Analyzers/Cz/ contrib/Analyzers/De/ contrib/Analyzers/Fr/ contrib/Analyzers/Miscellaneous/ contrib/Analyzers/N...
Date Sun, 06 Nov 2011 05:24:44 GMT
Modified: incubator/lucene.net/trunk/src/core/Search/Spans/NearSpansUnordered.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Spans/NearSpansUnordered.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Spans/NearSpansUnordered.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Spans/NearSpansUnordered.cs Sun Nov  6 05:24:26 2011
@@ -23,7 +23,7 @@ using PriorityQueue = Lucene.Net.Util.Pr
 namespace Lucene.Net.Search.Spans
 {
 	
-	/// <summary> Similar to {@link NearSpansOrdered}, but for the unordered case.
+	/// <summary> Similar to <see cref="NearSpansOrdered" />, but for the unordered case.
 	/// 
 	/// Expert:
 	/// Only public for subclassing.  Most implementations should not need this class
@@ -315,7 +315,7 @@ namespace Lucene.Net.Search.Spans
 		
 		// TODO: Remove warning after API has been finalized
 		/// <summary> WARNING: The List is not necessarily in order of the the positions</summary>
-		/// <returns> Collection of <code>byte[]</code> payloads
+		/// <returns> Collection of <c>byte[]</c> payloads
 		/// </returns>
 		/// <throws>  IOException </throws>
 		public override System.Collections.Generic.ICollection<byte[]> GetPayload()

Modified: incubator/lucene.net/trunk/src/core/Search/Spans/SpanFirstQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Spans/SpanFirstQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Spans/SpanFirstQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Spans/SpanFirstQuery.cs Sun Nov  6 05:24:26 2011
@@ -109,8 +109,8 @@ namespace Lucene.Net.Search.Spans
 		private SpanQuery match;
 		private int end;
 		
-		/// <summary>Construct a SpanFirstQuery matching spans in <code>match</code> whose end
-		/// position is less than or equal to <code>end</code>. 
+		/// <summary>Construct a SpanFirstQuery matching spans in <c>match</c> whose end
+		/// position is less than or equal to <c>end</c>. 
 		/// </summary>
 		public SpanFirstQuery(SpanQuery match, int end)
 		{
@@ -138,7 +138,7 @@ namespace Lucene.Net.Search.Spans
 		/// <summary>Returns a collection of all terms matched by this query.</summary>
 		/// <deprecated> use extractTerms instead
 		/// </deprecated>
-		/// <seealso cref="ExtractTerms(Set)">
+        /// <seealso cref="ExtractTerms(System.Collections.Hashtable)">
 		/// </seealso>
         [Obsolete("use ExtractTerms instead")]
 		public override System.Collections.ICollection GetTerms()

Modified: incubator/lucene.net/trunk/src/core/Search/Spans/SpanNearQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Spans/SpanNearQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Spans/SpanNearQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Spans/SpanNearQuery.cs Sun Nov  6 05:24:26 2011
@@ -39,9 +39,9 @@ namespace Lucene.Net.Search.Spans
 		private bool collectPayloads;
 		
 		/// <summary>Construct a SpanNearQuery.  Matches spans matching a span from each
-		/// clause, with up to <code>slop</code> total unmatched positions between
-		/// them.  * When <code>inOrder</code> is true, the spans from each clause
-		/// must be * ordered as in <code>clauses</code>. 
+		/// clause, with up to <c>slop</c> total unmatched positions between
+		/// them.  * When <c>inOrder</c> is true, the spans from each clause
+		/// must be * ordered as in <c>clauses</c>. 
 		/// </summary>
 		public SpanNearQuery(SpanQuery[] clauses, int slop, bool inOrder):this(clauses, slop, inOrder, true)
 		{
@@ -97,7 +97,7 @@ namespace Lucene.Net.Search.Spans
 		/// <summary>Returns a collection of all terms matched by this query.</summary>
 		/// <deprecated> use extractTerms instead
 		/// </deprecated>
-		/// <seealso cref="ExtractTerms(Set)">
+        /// <seealso cref="ExtractTerms(System.Collections.Hashtable)">
 		/// </seealso>
         [Obsolete("use ExtractTerms instead")]
 		public override System.Collections.ICollection GetTerms()
@@ -195,7 +195,7 @@ namespace Lucene.Net.Search.Spans
 			return spanNearQuery;
 		}
 		
-		/// <summary>Returns true iff <code>o</code> is equal to this. </summary>
+		/// <summary>Returns true iff <c>o</c> is equal to this. </summary>
 		public  override bool Equals(System.Object o)
 		{
 			if (this == o)

Modified: incubator/lucene.net/trunk/src/core/Search/Spans/SpanNotQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Spans/SpanNotQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Spans/SpanNotQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Spans/SpanNotQuery.cs Sun Nov  6 05:24:26 2011
@@ -145,8 +145,8 @@ namespace Lucene.Net.Search.Spans
 		private SpanQuery include;
 		private SpanQuery exclude;
 		
-		/// <summary>Construct a SpanNotQuery matching spans from <code>include</code> which
-		/// have no overlap with spans from <code>exclude</code>.
+		/// <summary>Construct a SpanNotQuery matching spans from <c>include</c> which
+		/// have no overlap with spans from <c>exclude</c>.
 		/// </summary>
 		public SpanNotQuery(SpanQuery include, SpanQuery exclude)
 		{
@@ -177,7 +177,7 @@ namespace Lucene.Net.Search.Spans
 		/// <summary>Returns a collection of all terms matched by this query.</summary>
 		/// <deprecated> use extractTerms instead
 		/// </deprecated>
-		/// <seealso cref="ExtractTerms(Set)">
+        /// <seealso cref="ExtractTerms(System.Collections.Hashtable)">
 		/// </seealso>
         [Obsolete("use ExtractTerms instead")]
 		public override System.Collections.ICollection GetTerms()
@@ -242,7 +242,7 @@ namespace Lucene.Net.Search.Spans
 			}
 		}
 		
-		/// <summary>Returns true iff <code>o</code> is equal to this. </summary>
+		/// <summary>Returns true iff <c>o</c> is equal to this. </summary>
 		public  override bool Equals(System.Object o)
 		{
 			if (this == o)

Modified: incubator/lucene.net/trunk/src/core/Search/Spans/SpanOrQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Spans/SpanOrQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Spans/SpanOrQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Spans/SpanOrQuery.cs Sun Nov  6 05:24:26 2011
@@ -200,7 +200,7 @@ namespace Lucene.Net.Search.Spans
 		/// <summary>Returns a collection of all terms matched by this query.</summary>
 		/// <deprecated> use extractTerms instead
 		/// </deprecated>
-		/// <seealso cref="ExtractTerms(Set)">
+        /// <seealso cref="ExtractTerms(System.Collections.Hashtable)">
 		/// </seealso>
         [Obsolete("use ExtractTerms instead")]
 		public override System.Collections.ICollection GetTerms()

Modified: incubator/lucene.net/trunk/src/core/Search/Spans/SpanQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Spans/SpanQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Spans/SpanQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Spans/SpanQuery.cs Sun Nov  6 05:24:26 2011
@@ -40,7 +40,7 @@ namespace Lucene.Net.Search.Spans
 		/// <summary>Returns a collection of all terms matched by this query.</summary>
 		/// <deprecated> use extractTerms instead
 		/// </deprecated>
-		/// <seealso cref="Query.ExtractTerms(Set)">
+		/// <seealso cref="Query.ExtractTerms(System.Collections.Hashtable)">
 		/// </seealso>
         [Obsolete("use ExtractTerms instead")]
 		public abstract System.Collections.ICollection GetTerms();

Modified: incubator/lucene.net/trunk/src/core/Search/Spans/SpanScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Spans/SpanScorer.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Spans/SpanScorer.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Spans/SpanScorer.cs Sun Nov  6 05:24:26 2011
@@ -59,7 +59,7 @@ namespace Lucene.Net.Search.Spans
 			}
 		}
 		
-		/// <deprecated> use {@link #NextDoc()} instead. 
+		/// <deprecated> use <see cref="NextDoc()" /> instead. 
 		/// </deprecated>
         [Obsolete("use NextDoc() instead.")]
 		public override bool Next()
@@ -76,7 +76,7 @@ namespace Lucene.Net.Search.Spans
 			return doc;
 		}
 		
-		/// <deprecated> use {@link #Advance(int)} instead. 
+		/// <deprecated> use <see cref="Advance(int)" /> instead. 
 		/// </deprecated>
         [Obsolete("use Advance(int) instead. ")]
 		public override bool SkipTo(int target)
@@ -120,7 +120,7 @@ namespace Lucene.Net.Search.Spans
 			return true;
 		}
 		
-		/// <deprecated> use {@link #DocID()} instead. 
+		/// <deprecated> use <see cref="DocID()" /> instead. 
 		/// </deprecated>
         [Obsolete("use DocID() instead. ")]
 		public override int Doc()

Modified: incubator/lucene.net/trunk/src/core/Search/Spans/SpanTermQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Spans/SpanTermQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Spans/SpanTermQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Spans/SpanTermQuery.cs Sun Nov  6 05:24:26 2011
@@ -50,7 +50,7 @@ namespace Lucene.Net.Search.Spans
 		/// <summary>Returns a collection of all terms matched by this query.</summary>
 		/// <deprecated> use extractTerms instead
 		/// </deprecated>
-		/// <seealso cref="ExtractTerms(Set)">
+        /// <seealso cref="ExtractTerms(System.Collections.Hashtable)">
 		/// </seealso>
         [Obsolete("use extractTerms instead")]
 		public override System.Collections.ICollection GetTerms()

Modified: incubator/lucene.net/trunk/src/core/Search/Spans/Spans.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Spans/Spans.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Spans/Spans.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Spans/Spans.cs Sun Nov  6 05:24:26 2011
@@ -32,7 +32,7 @@ namespace Lucene.Net.Search.Spans
 		
 		/// <summary>Skips to the first match beyond the current, whose document number is
 		/// greater than or equal to <i>target</i>. <p/>Returns true iff there is such
-		/// a match.  <p/>Behaves as if written: <pre>
+        /// a match.  <p/>Behaves as if written: <code>
 		/// boolean skipTo(int target) {
 		/// do {
 		/// if (!next())
@@ -40,7 +40,7 @@ namespace Lucene.Net.Search.Spans
 		/// } while (target > doc());
 		/// return true;
 		/// }
-		/// </pre>
+        /// </code>
 		/// Most implementations are considerably more efficient than that.
 		/// </summary>
 		public abstract bool SkipTo(int target);
@@ -55,10 +55,10 @@ namespace Lucene.Net.Search.Spans
 		public abstract int End();
 		
 		/// <summary> Returns the payload data for the current span.
-		/// This is invalid until {@link #Next()} is called for
+		/// This is invalid until <see cref="Next()" /> is called for
 		/// the first time.
 		/// This method must not be called more than once after each call
-		/// of {@link #Next()}. However, most payloads are loaded lazily,
+		/// of <see cref="Next()" />. However, most payloads are loaded lazily,
 		/// so if the payload data for the current position is not needed,
 		/// this method may not be called at all for performance reasons. An ordered
 		/// SpanQuery does not lazy load, so if you have payloads in your index and
@@ -82,7 +82,7 @@ namespace Lucene.Net.Search.Spans
 		/// <summary> Checks if a payload can be loaded at this position.
 		/// <p/>
 		/// Payloads can only be loaded once per call to
-		/// {@link #Next()}.
+		/// <see cref="Next()" />.
 		/// 
 		/// </summary>
 		/// <returns> true if there is a payload available at this position that can be loaded

Modified: incubator/lucene.net/trunk/src/core/Search/TermQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/TermQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/TermQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/TermQuery.cs Sun Nov  6 05:24:26 2011
@@ -27,7 +27,7 @@ namespace Lucene.Net.Search
 {
 	
 	/// <summary>A Query that matches documents containing a term.
-	/// This may be combined with other terms with a {@link BooleanQuery}.
+	/// This may be combined with other terms with a <see cref="BooleanQuery" />.
 	/// </summary>
 	[Serializable]
 	public class TermQuery:Query
@@ -159,7 +159,7 @@ namespace Lucene.Net.Search
 			}
 		}
 		
-		/// <summary>Constructs a query for the term <code>t</code>. </summary>
+		/// <summary>Constructs a query for the term <c>t</c>. </summary>
 		public TermQuery(Term t)
 		{
 			term = t;
@@ -195,7 +195,7 @@ namespace Lucene.Net.Search
 			return buffer.ToString();
 		}
 		
-		/// <summary>Returns true iff <code>o</code> is equal to this. </summary>
+		/// <summary>Returns true iff <c>o</c> is equal to this. </summary>
 		public  override bool Equals(System.Object o)
 		{
 			if (!(o is TermQuery))

Modified: incubator/lucene.net/trunk/src/core/Search/TermRangeFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/TermRangeFilter.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/TermRangeFilter.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/TermRangeFilter.cs Sun Nov  6 05:24:26 2011
@@ -24,11 +24,11 @@ namespace Lucene.Net.Search
 	/// field.
 	/// 
 	/// <p/>This filter matches the documents looking for terms that fall into the
-	/// supplied range according to {@link String#compareTo(String)}. It is not intended
-	/// for numerical ranges, use {@link NumericRangeFilter} instead.
+	/// supplied range according to <see cref="String.CompareTo(String)" />. It is not intended
+	/// for numerical ranges, use <see cref="NumericRangeFilter" /> instead.
 	/// 
 	/// <p/>If you construct a large number of range filters with different ranges but on the 
-	/// same field, {@link FieldCacheRangeFilter} may have significantly better performance. 
+	/// same field, <see cref="FieldCacheRangeFilter" /> may have significantly better performance. 
 	/// </summary>
 	/// <since> 2.9
 	/// </since>
@@ -53,43 +53,44 @@ namespace Lucene.Net.Search
 		public TermRangeFilter(System.String fieldName, System.String lowerTerm, System.String upperTerm, bool includeLower, bool includeUpper):base(new TermRangeQuery(fieldName, lowerTerm, upperTerm, includeLower, includeUpper))
 		{
 		}
-		
-		/// <summary> <strong>WARNING:</strong> Using this constructor and supplying a non-null
-		/// value in the <code>collator</code> parameter will cause every single 
-		/// index Term in the Field referenced by lowerTerm and/or upperTerm to be
-		/// examined.  Depending on the number of index Terms in this Field, the 
-		/// operation could be very slow.
-		/// 
-		/// </summary>
-		/// <param name="lowerTerm">The lower bound on this range
-		/// </param>
-		/// <param name="upperTerm">The upper bound on this range
-		/// </param>
-		/// <param name="includeLower">Does this range include the lower bound?
-		/// </param>
-		/// <param name="includeUpper">Does this range include the upper bound?
-		/// </param>
-		/// <param name="collator">The collator to use when determining range inclusion; set
-		/// to null to use Unicode code point ordering instead of collation.
-		/// </param>
-		/// <throws>  IllegalArgumentException if both terms are null or if </throws>
-		/// <summary>  lowerTerm is null and includeLower is true (similar for upperTerm
-		/// and includeUpper)
-		/// </summary>
-		public TermRangeFilter(System.String fieldName, System.String lowerTerm, System.String upperTerm, bool includeLower, bool includeUpper, System.Globalization.CompareInfo collator):base(new TermRangeQuery(fieldName, lowerTerm, upperTerm, includeLower, includeUpper, collator))
+
+	    /// <summary> <strong>WARNING:</strong> Using this constructor and supplying a non-null
+	    /// value in the <c>collator</c> parameter will cause every single 
+	    /// index Term in the Field referenced by lowerTerm and/or upperTerm to be
+	    /// examined.  Depending on the number of index Terms in this Field, the 
+	    /// operation could be very slow.
+	    /// 
+	    /// </summary>
+	    /// <param name="fieldName"></param>
+	    /// <param name="lowerTerm">The lower bound on this range
+	    /// </param>
+	    /// <param name="upperTerm">The upper bound on this range
+	    /// </param>
+	    /// <param name="includeLower">Does this range include the lower bound?
+	    /// </param>
+	    /// <param name="includeUpper">Does this range include the upper bound?
+	    /// </param>
+	    /// <param name="collator">The collator to use when determining range inclusion; set
+	    /// to null to use Unicode code point ordering instead of collation.
+	    /// </param>
+	    /// <throws>  IllegalArgumentException if both terms are null or if </throws>
+	    /// <summary>  lowerTerm is null and includeLower is true (similar for upperTerm
+	    /// and includeUpper)
+	    /// </summary>
+	    public TermRangeFilter(System.String fieldName, System.String lowerTerm, System.String upperTerm, bool includeLower, bool includeUpper, System.Globalization.CompareInfo collator):base(new TermRangeQuery(fieldName, lowerTerm, upperTerm, includeLower, includeUpper, collator))
 		{
 		}
 		
-		/// <summary> Constructs a filter for field <code>fieldName</code> matching
-		/// less than or equal to <code>upperTerm</code>.
+		/// <summary> Constructs a filter for field <c>fieldName</c> matching
+		/// less than or equal to <c>upperTerm</c>.
 		/// </summary>
 		public static TermRangeFilter Less(System.String fieldName, System.String upperTerm)
 		{
 			return new TermRangeFilter(fieldName, null, upperTerm, false, true);
 		}
 		
-		/// <summary> Constructs a filter for field <code>fieldName</code> matching
-		/// greater than or equal to <code>lowerTerm</code>.
+		/// <summary> Constructs a filter for field <c>fieldName</c> matching
+		/// greater than or equal to <c>lowerTerm</c>.
 		/// </summary>
 		public static TermRangeFilter More(System.String fieldName, System.String lowerTerm)
 		{
@@ -114,13 +115,13 @@ namespace Lucene.Net.Search
 			return ((TermRangeQuery) query).GetUpperTerm();
 		}
 		
-		/// <summary>Returns <code>true</code> if the lower endpoint is inclusive </summary>
+		/// <summary>Returns <c>true</c> if the lower endpoint is inclusive </summary>
 		public virtual bool IncludesLower()
 		{
 			return ((TermRangeQuery) query).IncludesLower();
 		}
 		
-		/// <summary>Returns <code>true</code> if the upper endpoint is inclusive </summary>
+		/// <summary>Returns <c>true</c> if the upper endpoint is inclusive </summary>
 		public virtual bool IncludesUpper()
 		{
 			return ((TermRangeQuery) query).IncludesUpper();

Modified: incubator/lucene.net/trunk/src/core/Search/TermRangeQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/TermRangeQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/TermRangeQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/TermRangeQuery.cs Sun Nov  6 05:24:26 2011
@@ -26,11 +26,11 @@ namespace Lucene.Net.Search
 	/// <summary> A Query that matches documents within an exclusive range of terms.
 	/// 
 	/// <p/>This query matches the documents looking for terms that fall into the
-	/// supplied range according to {@link String#compareTo(String)}. It is not intended
-	/// for numerical ranges, use {@link NumericRangeQuery} instead.
+	/// supplied range according to <see cref="String.CompareTo(String)" />. It is not intended
+	/// for numerical ranges, use <see cref="NumericRangeQuery" /> instead.
 	/// 
-	/// <p/>This query uses the {@link
-	/// MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}
+	/// <p/>This query uses the <see cref="MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT" />
+	///
 	/// rewrite method.
 	/// </summary>
 	/// <since> 2.9
@@ -47,8 +47,8 @@ namespace Lucene.Net.Search
 		private bool includeUpper;
 		
 		
-		/// <summary> Constructs a query selecting all terms greater/equal than <code>lowerTerm</code>
-		/// but less/equal than <code>upperTerm</code>. 
+		/// <summary> Constructs a query selecting all terms greater/equal than <c>lowerTerm</c>
+		/// but less/equal than <c>upperTerm</c>. 
 		/// 
 		/// <p/>
 		/// If an endpoint is null, it is said 
@@ -63,50 +63,51 @@ namespace Lucene.Net.Search
 		/// </param>
 		/// <param name="upperTerm">The term text at the upper end of the range
 		/// </param>
-		/// <param name="includeLower">If true, the <code>lowerTerm</code> is
+		/// <param name="includeLower">If true, the <c>lowerTerm</c> is
 		/// included in the range.
 		/// </param>
-		/// <param name="includeUpper">If true, the <code>upperTerm</code> is
+		/// <param name="includeUpper">If true, the <c>upperTerm</c> is
 		/// included in the range.
 		/// </param>
 		public TermRangeQuery(System.String field, System.String lowerTerm, System.String upperTerm, bool includeLower, bool includeUpper):this(field, lowerTerm, upperTerm, includeLower, includeUpper, null)
 		{
 		}
-		
-		/// <summary>Constructs a query selecting all terms greater/equal than
-		/// <code>lowerTerm</code> but less/equal than <code>upperTerm</code>.
-		/// <p/>
-		/// If an endpoint is null, it is said 
-		/// to be "open". Either or both endpoints may be open.  Open endpoints may not 
-		/// be exclusive (you can't select all but the first or last term without 
-		/// explicitly specifying the term to exclude.)
-		/// <p/>
-		/// If <code>collator</code> is not null, it will be used to decide whether
-		/// index terms are within the given range, rather than using the Unicode code
-		/// point order in which index terms are stored.
-		/// <p/>
-		/// <strong>WARNING:</strong> Using this constructor and supplying a non-null
-		/// value in the <code>collator</code> parameter will cause every single 
-		/// index Term in the Field referenced by lowerTerm and/or upperTerm to be
-		/// examined.  Depending on the number of index Terms in this Field, the 
-		/// operation could be very slow.
-		/// 
-		/// </summary>
-		/// <param name="lowerTerm">The Term text at the lower end of the range
-		/// </param>
-		/// <param name="upperTerm">The Term text at the upper end of the range
-		/// </param>
-		/// <param name="includeLower">If true, the <code>lowerTerm</code> is
-		/// included in the range.
-		/// </param>
-		/// <param name="includeUpper">If true, the <code>upperTerm</code> is
-		/// included in the range.
-		/// </param>
-		/// <param name="collator">The collator to use to collate index Terms, to determine
-		/// their membership in the range bounded by <code>lowerTerm</code> and
-		/// <code>upperTerm</code>.
-		/// </param>
-		public TermRangeQuery(System.String field, System.String lowerTerm, System.String upperTerm, bool includeLower, bool includeUpper, System.Globalization.CompareInfo collator)
+
+	    /// <summary>Constructs a query selecting all terms greater/equal than
+	    /// <c>lowerTerm</c> but less/equal than <c>upperTerm</c>.
+	    /// <p/>
+	    /// If an endpoint is null, it is said 
+	    /// to be "open". Either or both endpoints may be open.  Open endpoints may not 
+	    /// be exclusive (you can't select all but the first or last term without 
+	    /// explicitly specifying the term to exclude.)
+	    /// <p/>
+	    /// If <c>collator</c> is not null, it will be used to decide whether
+	    /// index terms are within the given range, rather than using the Unicode code
+	    /// point order in which index terms are stored.
+	    /// <p/>
+	    /// <strong>WARNING:</strong> Using this constructor and supplying a non-null
+	    /// value in the <c>collator</c> parameter will cause every single 
+	    /// index Term in the Field referenced by lowerTerm and/or upperTerm to be
+	    /// examined.  Depending on the number of index Terms in this Field, the 
+	    /// operation could be very slow.
+	    /// 
+	    /// </summary>
+	    /// <param name="field"></param>
+	    /// <param name="lowerTerm">The Term text at the lower end of the range
+	    /// </param>
+	    /// <param name="upperTerm">The Term text at the upper end of the range
+	    /// </param>
+	    /// <param name="includeLower">If true, the <c>lowerTerm</c> is
+	    /// included in the range.
+	    /// </param>
+	    /// <param name="includeUpper">If true, the <c>upperTerm</c> is
+	    /// included in the range.
+	    /// </param>
+	    /// <param name="collator">The collator to use to collate index Terms, to determine
+	    /// their membership in the range bounded by <c>lowerTerm</c> and
+	    /// <c>upperTerm</c>.
+	    /// </param>
+	    public TermRangeQuery(System.String field, System.String lowerTerm, System.String upperTerm, bool includeLower, bool includeUpper, System.Globalization.CompareInfo collator)
 		{
 			this.field = field;
 			this.lowerTerm = lowerTerm;
@@ -134,13 +135,13 @@ namespace Lucene.Net.Search
 			return upperTerm;
 		}
 		
-		/// <summary>Returns <code>true</code> if the lower endpoint is inclusive </summary>
+		/// <summary>Returns <c>true</c> if the lower endpoint is inclusive </summary>
 		public virtual bool IncludesLower()
 		{
 			return includeLower;
 		}
 		
-		/// <summary>Returns <code>true</code> if the upper endpoint is inclusive </summary>
+		/// <summary>Returns <c>true</c> if the upper endpoint is inclusive </summary>
 		public virtual bool IncludesUpper()
 		{
 			return includeUpper;

Modified: incubator/lucene.net/trunk/src/core/Search/TermRangeTermEnum.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/TermRangeTermEnum.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/TermRangeTermEnum.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/TermRangeTermEnum.cs Sun Nov  6 05:24:26 2011
@@ -43,8 +43,8 @@ namespace Lucene.Net.Search
 		private bool includeLower;
 		private bool includeUpper;
 		
-		/// <summary> Enumerates all terms greater/equal than <code>lowerTerm</code>
-		/// but less/equal than <code>upperTerm</code>. 
+		/// <summary> Enumerates all terms greater/equal than <c>lowerTerm</c>
+		/// but less/equal than <c>upperTerm</c>. 
 		/// 
 		/// If an endpoint is null, it is said to be "open". Either or both 
 		/// endpoints may be open.  Open endpoints may not be exclusive 
@@ -60,13 +60,13 @@ namespace Lucene.Net.Search
 		/// </param>
 		/// <param name="upperTermText">The term text at the upper end of the range
 		/// </param>
-		/// <param name="includeLower">If true, the <code>lowerTerm</code> is included in the range.
+		/// <param name="includeLower">If true, the <c>lowerTerm</c> is included in the range.
 		/// </param>
-		/// <param name="includeUpper">If true, the <code>upperTerm</code> is included in the range.
+		/// <param name="includeUpper">If true, the <c>upperTerm</c> is included in the range.
 		/// </param>
 		/// <param name="collator">The collator to use to collate index Terms, to determine their
-		/// membership in the range bounded by <code>lowerTerm</code> and
-		/// <code>upperTerm</code>.
+		/// membership in the range bounded by <c>lowerTerm</c> and
+		/// <c>upperTerm</c>.
 		/// 
 		/// </param>
 		/// <throws>  IOException </throws>

Modified: incubator/lucene.net/trunk/src/core/Search/TermScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/TermScorer.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/TermScorer.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/TermScorer.cs Sun Nov  6 05:24:26 2011
@@ -22,7 +22,7 @@ using TermDocs = Lucene.Net.Index.TermDo
 namespace Lucene.Net.Search
 {
 	
-	/// <summary>Expert: A <code>Scorer</code> for documents matching a <code>Term</code>.</summary>
+	/// <summary>Expert: A <c>Scorer</c> for documents matching a <c>Term</c>.</summary>
 	public sealed class TermScorer:Scorer
 	{
 		
@@ -42,17 +42,17 @@ namespace Lucene.Net.Search
 		private const int SCORE_CACHE_SIZE = 32;
 		private float[] scoreCache = new float[SCORE_CACHE_SIZE];
 		
-		/// <summary> Construct a <code>TermScorer</code>.
+		/// <summary> Construct a <c>TermScorer</c>.
 		/// 
 		/// </summary>
-		/// <param name="weight">The weight of the <code>Term</code> in the query.
+		/// <param name="weight">The weight of the <c>Term</c> in the query.
 		/// </param>
-		/// <param name="td">An iterator over the documents matching the <code>Term</code>.
+		/// <param name="td">An iterator over the documents matching the <c>Term</c>.
 		/// </param>
-		/// <param name="similarity">The <code>Similarity</code> implementation to be used for score
+		/// <param name="similarity">The <c>Similarity</c> implementation to be used for score
 		/// computations.
 		/// </param>
-		/// <param name="norms">The field norms of the document fields for the <code>Term</code>.
+		/// <param name="norms">The field norms of the document fields for the <c>Term</c>.
 		/// </param>
 		public /*internal*/ TermScorer(Weight weight, TermDocs td, Similarity similarity, byte[] norms):base(similarity)
 		{
@@ -65,7 +65,7 @@ namespace Lucene.Net.Search
 				scoreCache[i] = GetSimilarity().Tf(i) * weightValue;
 		}
 		
-		/// <deprecated> use {@link #Score(Collector)} instead. 
+		/// <deprecated> use <see cref="Score(Collector)" /> instead. 
 		/// </deprecated>
         [Obsolete("use Score(Collector) instead. ")]
 		public override void  Score(HitCollector hc)
@@ -78,7 +78,7 @@ namespace Lucene.Net.Search
 			Score(c, System.Int32.MaxValue, NextDoc());
 		}
 		
-		/// <deprecated> use {@link #Score(Collector, int, int)} instead. 
+		/// <deprecated> use <see cref="Score(Collector, int, int)" /> instead. 
 		/// </deprecated>
         [Obsolete("use Score(Collector, int, int) instead.")]
 		protected internal override bool Score(HitCollector c, int end)
@@ -114,7 +114,7 @@ namespace Lucene.Net.Search
 			return true;
 		}
 		
-		/// <deprecated> use {@link #DocID()} instead. 
+		/// <deprecated> use <see cref="DocID()" /> instead. 
 		/// </deprecated>
         [Obsolete("use DocID() instead. ")]
 		public override int Doc()
@@ -129,12 +129,12 @@ namespace Lucene.Net.Search
 		
 		/// <summary> Advances to the next document matching the query. <br/>
 		/// The iterator over the matching documents is buffered using
-		/// {@link TermDocs#Read(int[],int[])}.
+		/// <see cref="TermDocs.Read(int[],int[])" />.
 		/// 
 		/// </summary>
 		/// <returns> true iff there is another document matching the query.
 		/// </returns>
-		/// <deprecated> use {@link #NextDoc()} instead.
+		/// <deprecated> use <see cref="NextDoc()" /> instead.
 		/// </deprecated>
         [Obsolete("use NextDoc() instead.")]
 		public override bool Next()
@@ -144,7 +144,7 @@ namespace Lucene.Net.Search
 		
 		/// <summary> Advances to the next document matching the query. <br/>
 		/// The iterator over the matching documents is buffered using
-		/// {@link TermDocs#Read(int[],int[])}.
+		/// <see cref="TermDocs.Read(int[],int[])" />.
 		/// 
 		/// </summary>
 		/// <returns> the document matching the query or -1 if there are no more documents.
@@ -180,14 +180,14 @@ namespace Lucene.Net.Search
 		
 		/// <summary> Skips to the first match beyond the current whose document number is
 		/// greater than or equal to a given target. <br/>
-		/// The implementation uses {@link TermDocs#SkipTo(int)}.
+		/// The implementation uses <see cref="TermDocs.SkipTo(int)" />.
 		/// 
 		/// </summary>
 		/// <param name="target">The target document number.
 		/// </param>
 		/// <returns> true iff there is such a match.
 		/// </returns>
-		/// <deprecated> use {@link #Advance(int)} instead.
+		/// <deprecated> use <see cref="Advance(int)" /> instead.
 		/// </deprecated>
         [Obsolete("use Advance(int) instead.")]
 		public override bool SkipTo(int target)
@@ -197,7 +197,7 @@ namespace Lucene.Net.Search
 		
 		/// <summary> Advances to the first match beyond the current whose document number is
 		/// greater than or equal to a given target. <br/>
-		/// The implementation uses {@link TermDocs#SkipTo(int)}.
+		/// The implementation uses <see cref="TermDocs.SkipTo(int)" />.
 		/// 
 		/// </summary>
 		/// <param name="target">The target document number.
@@ -232,8 +232,8 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary>Returns an explanation of the score for a document.
-		/// <br/>When this method is used, the {@link #Next()} method
-		/// and the {@link #Score(HitCollector)} method should not be used.
+		/// <br/>When this method is used, the <see cref="Next()" /> method
+		/// and the <see cref="Score(HitCollector)" /> method should not be used.
 		/// </summary>
 		/// <param name="doc">The document number for the explanation.
 		/// </param>
@@ -265,7 +265,7 @@ namespace Lucene.Net.Search
 			return tfExplanation;
 		}
 		
-		/// <summary>Returns a string representation of this <code>TermScorer</code>. </summary>
+		/// <summary>Returns a string representation of this <c>TermScorer</c>. </summary>
 		public override System.String ToString()
 		{
 			return "scorer(" + weight + ")";

Modified: incubator/lucene.net/trunk/src/core/Search/TimeLimitedCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/TimeLimitedCollector.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/TimeLimitedCollector.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/TimeLimitedCollector.cs Sun Nov  6 05:24:26 2011
@@ -27,8 +27,8 @@ namespace Lucene.Net.Search
 	/// <p/>
 	/// 
 	/// </summary>
-	/// <deprecated> Use {@link TimeLimitingCollector} instead, which extends the new
-	/// {@link Collector}. This class will be removed in 3.0.
+	/// <deprecated> Use <see cref="TimeLimitingCollector" /> instead, which extends the new
+	/// <see cref="Collector" />. This class will be removed in 3.0.
 	/// </deprecated>
     [Obsolete("Use TimeLimitingCollector instead, which extends the new Collector. This class will be removed in 3.0.")]
 	public class TimeLimitedCollector:HitCollector
@@ -39,11 +39,11 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary> Default timer resolution.</summary>
-		/// <seealso cref="SetResolution(long)">
+		/// <seealso cref="SetResolution(uint)">
 		/// </seealso>
 		public const int DEFAULT_RESOLUTION = 20;
 		
-		/// <summary> Default for {@link #IsGreedy()}.</summary>
+		/// <summary> Default for <see cref="IsGreedy()" />.</summary>
 		/// <seealso cref="IsGreedy()">
 		/// </seealso>
 		public bool DEFAULT_GREEDY = false;
@@ -144,7 +144,7 @@ namespace Lucene.Net.Search
 		/// <summary> Create a TimeLimitedCollector wrapper over another HitCollector with a specified timeout.</summary>
 		/// <param name="hc">the wrapped HitCollector
 		/// </param>
-		/// <param name="timeAllowed">max time allowed for collecting hits after which {@link TimeExceededException} is thrown
+		/// <param name="timeAllowed">max time allowed for collecting hits after which <see cref="TimeExceededException" /> is thrown
 		/// </param>
 		public TimeLimitedCollector(HitCollector hc, long timeAllowed)
 		{
@@ -176,7 +176,7 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary> Return the timer resolution.</summary>
-		/// <seealso cref="SetResolution(long)">
+		/// <seealso cref="SetResolution(uint)">
 		/// </seealso>
 		public static long GetResolution()
 		{
@@ -188,13 +188,13 @@ namespace Lucene.Net.Search
 		/// This means that a search required to take no longer than 
 		/// 800 milliseconds may be stopped after 780 to 820 milliseconds.
 		/// <br/>Note that: 
-		/// <ul>
-		/// <li>Finer (smaller) resolution is more accurate but less efficient.</li>
-		/// <li>Setting resolution to less than 5 milliseconds will be silently modified to 5 milliseconds.</li>
-		/// <li>Setting resolution smaller than current resolution might take effect only after current 
+		/// <list type="bullet">
+		/// <item>Finer (smaller) resolution is more accurate but less efficient.</item>
+		/// <item>Setting resolution to less than 5 milliseconds will be silently modified to 5 milliseconds.</item>
+		/// <item>Setting resolution smaller than current resolution might take effect only after current 
 		/// resolution. (Assume current resolution of 20 milliseconds is modified to 5 milliseconds, 
-		/// then it can take up to 20 milliseconds for the change to have effect.</li>
-		/// </ul>      
+		/// then it can take up to 20 milliseconds for the change to have effect.</item>
+		/// </list>      
 		/// </summary>
 		public static void  SetResolution(uint newResolution)
 		{
@@ -202,12 +202,12 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary> Checks if this time limited collector is greedy in collecting the last hit.
-		/// A non greedy collector, upon a timeout, would throw a {@link TimeExceededException} 
+		/// A non greedy collector, upon a timeout, would throw a <see cref="TimeExceededException" /> 
 		/// without allowing the wrapped collector to collect current doc. A greedy one would 
 		/// first allow the wrapped hit collector to collect current doc and only then 
-		/// throw a {@link TimeExceededException}.
+		/// throw a <see cref="TimeExceededException" />.
 		/// </summary>
-		/// <seealso cref="SetGreedy(boolean)">
+		/// <seealso cref="SetGreedy(bool)">
 		/// </seealso>
 		public virtual bool IsGreedy()
 		{

Modified: incubator/lucene.net/trunk/src/core/Search/TimeLimitingCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/TimeLimitingCollector.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/TimeLimitingCollector.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/TimeLimitingCollector.cs Sun Nov  6 05:24:26 2011
@@ -22,10 +22,10 @@ using IndexReader = Lucene.Net.Index.Ind
 namespace Lucene.Net.Search
 {
 	
-	/// <summary> The {@link TimeLimitingCollector} is used to timeout search requests that
+	/// <summary> The <see cref="TimeLimitingCollector" /> is used to timeout search requests that
 	/// take longer than the maximum allowed search time limit. After this time is
 	/// exceeded, the search thread is stopped by throwing a
-	/// {@link TimeExceededException}.
+	/// <see cref="TimeExceededException" />.
 	/// </summary>
 	public class TimeLimitingCollector:Collector
 	{
@@ -35,11 +35,11 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary> Default timer resolution.</summary>
-		/// <seealso cref="SetResolution(long)">
+		/// <seealso cref="SetResolution(uint)">
 		/// </seealso>
 		public const uint DEFAULT_RESOLUTION = 20;
 		
-		/// <summary> Default for {@link #IsGreedy()}.</summary>
+		/// <summary> Default for <see cref="IsGreedy()" />.</summary>
 		/// <seealso cref="IsGreedy()">
 		/// </seealso>
 		public bool DEFAULT_GREEDY = false;
@@ -139,10 +139,10 @@ namespace Lucene.Net.Search
 
         private int docBase;
 		
-		/// <summary> Create a TimeLimitedCollector wrapper over another {@link Collector} with a specified timeout.</summary>
-		/// <param name="collector">the wrapped {@link Collector}
+		/// <summary> Create a TimeLimitedCollector wrapper over another <see cref="Collector" /> with a specified timeout.</summary>
+		/// <param name="collector">the wrapped <see cref="Collector" />
 		/// </param>
-		/// <param name="timeAllowed">max time allowed for collecting hits after which {@link TimeExceededException} is thrown
+		/// <param name="timeAllowed">max time allowed for collecting hits after which <see cref="TimeExceededException" /> is thrown
 		/// </param>
 		public TimeLimitingCollector(Collector collector, long timeAllowed)
 		{
@@ -153,7 +153,7 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary> Return the timer resolution.</summary>
-		/// <seealso cref="SetResolution(long)">
+		/// <seealso cref="SetResolution(uint)">
 		/// </seealso>
 		public static long GetResolution()
 		{
@@ -165,13 +165,13 @@ namespace Lucene.Net.Search
 		/// This means that a search required to take no longer than 
 		/// 800 milliseconds may be stopped after 780 to 820 milliseconds.
 		/// <br/>Note that: 
-		/// <ul>
-		/// <li>Finer (smaller) resolution is more accurate but less efficient.</li>
-		/// <li>Setting resolution to less than 5 milliseconds will be silently modified to 5 milliseconds.</li>
-		/// <li>Setting resolution smaller than current resolution might take effect only after current 
+		/// <list type="bullet">
+		/// <item>Finer (smaller) resolution is more accurate but less efficient.</item>
+		/// <item>Setting resolution to less than 5 milliseconds will be silently modified to 5 milliseconds.</item>
+		/// <item>Setting resolution smaller than current resolution might take effect only after current 
 		/// resolution. (Assume current resolution of 20 milliseconds is modified to 5 milliseconds, 
-		/// then it can take up to 20 milliseconds for the change to have effect.</li>
-		/// </ul>      
+		/// then it can take up to 20 milliseconds for the change to have effect.</item>
+		/// </list>      
 		/// </summary>
 		public static void  SetResolution(uint newResolution)
 		{
@@ -179,12 +179,12 @@ namespace Lucene.Net.Search
 		}
 		
 		/// <summary> Checks if this time limited collector is greedy in collecting the last hit.
-		/// A non greedy collector, upon a timeout, would throw a {@link TimeExceededException} 
+		/// A non greedy collector, upon a timeout, would throw a <see cref="TimeExceededException" /> 
 		/// without allowing the wrapped collector to collect current doc. A greedy one would 
 		/// first allow the wrapped hit collector to collect current doc and only then 
-		/// throw a {@link TimeExceededException}.
+		/// throw a <see cref="TimeExceededException" />.
 		/// </summary>
-		/// <seealso cref="SetGreedy(boolean)">
+		/// <seealso cref="SetGreedy(bool)">
 		/// </seealso>
 		public virtual bool IsGreedy()
 		{
@@ -201,7 +201,7 @@ namespace Lucene.Net.Search
 			this.greedy = greedy;
 		}
 		
-		/// <summary> Calls {@link Collector#Collect(int)} on the decorated {@link Collector}
+		/// <summary> Calls <see cref="Collector.Collect(int)" /> on the decorated <see cref="Collector" />
 		/// unless the allowed time has passed, in which case it throws an exception.
 		/// 
 		/// </summary>

Modified: incubator/lucene.net/trunk/src/core/Search/TopDocCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/TopDocCollector.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/TopDocCollector.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/TopDocCollector.cs Sun Nov  6 05:24:26 2011
@@ -22,16 +22,16 @@ using PriorityQueue = Lucene.Net.Util.Pr
 namespace Lucene.Net.Search
 {
 	
-	/// <summary>A {@link HitCollector} implementation that collects the top-scoring
-	/// documents, returning them as a {@link TopDocs}.  This is used by {@link
-	/// IndexSearcher} to implement {@link TopDocs}-based search.
+	/// <summary>A <see cref="HitCollector" /> implementation that collects the top-scoring
+	/// documents, returning them as a <see cref="TopDocs" />.  This is used by <see cref="IndexSearcher" />
+	/// to implement <see cref="TopDocs" />-based search.
 	/// 
 	/// <p/>This may be extended, overriding the collect method to, e.g.,
-	/// conditionally invoke <code>super()</code> in order to filter which
+	/// conditionally invoke <c>super()</c> in order to filter which
 	/// documents are collected.
 	/// 
 	/// </summary>
-	/// <deprecated> Please use {@link TopScoreDocCollector}
+	/// <deprecated> Please use <see cref="TopScoreDocCollector" />
 	/// instead, which has better performance.
 	/// 
 	/// </deprecated>

Modified: incubator/lucene.net/trunk/src/core/Search/TopDocs.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/TopDocs.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/TopDocs.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/TopDocs.cs Sun Nov  6 05:24:26 2011
@@ -20,9 +20,8 @@ using System;
 namespace Lucene.Net.Search
 {
 	
-	/// <summary> Represents hits returned by {@link
-    /// * Searcher#search(Query,Filter,int)} and {@link
-    /// * Searcher#search(Query,int)
+	/// <summary> Represents hits returned by <see cref="Searcher.Search(Query,Filter,int)" />
+    /// and <see cref="Searcher.Search(Query,int)" />
     /// </summary>
 	[Serializable]
 	public class TopDocs
@@ -59,7 +58,7 @@ namespace Lucene.Net.Search
 
 
 		/// <summary>Returns the maximum score value encountered. Note that in case
-		/// scores are not tracked, this returns {@link Float#NaN}.
+		/// scores are not tracked, this returns <see cref="float.NaN" />.
 		/// </summary>
 		public virtual float GetMaxScore()
 		{

Modified: incubator/lucene.net/trunk/src/core/Search/TopDocsCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/TopDocsCollector.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/TopDocsCollector.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/TopDocsCollector.cs Sun Nov  6 05:24:26 2011
@@ -22,12 +22,12 @@ using PriorityQueue = Lucene.Net.Util.Pr
 namespace Lucene.Net.Search
 {
 	
-	/// <summary> A base class for all collectors that return a {@link TopDocs} output. This
+	/// <summary> A base class for all collectors that return a <see cref="Lucene.Net.Search.TopDocs" /> output. This
 	/// collector allows easy extension by providing a single constructor which
-	/// accepts a {@link PriorityQueue} as well as protected members for that
+	/// accepts a <see cref="PriorityQueue" /> as well as protected members for that
 	/// priority queue and a counter of the number of total hits.<br/>
-	/// Extending classes can override {@link #TopDocs(int, int)} and
-	/// {@link #GetTotalHits()} in order to provide their own implementation.
+	/// Extending classes can override <see cref="TopDocs(int, int)" /> and
+	/// <see cref="GetTotalHits()" /> in order to provide their own implementation.
 	/// </summary>
 	public abstract class TopDocsCollector:Collector
 	{
@@ -61,9 +61,9 @@ namespace Lucene.Net.Search
 				results[i] = (ScoreDoc) pq.Pop();
 			}
 		}
-		
-		/// <summary> Returns a {@link TopDocs} instance containing the given results. If
-		/// <code>results</code> is null it means there are no results to return,
+
+        /// <summary> Returns a <see cref="Lucene.Net.Search.TopDocs" /> instance containing the given results. If
+		/// <c>results</c> is null it means there are no results to return,
 		/// either because there were 0 calls to collect() or because the arguments to
 		/// topDocs were invalid.
 		/// </summary>
@@ -94,8 +94,8 @@ namespace Lucene.Net.Search
 		/// last results, starting from the last 'page'.<br/>
 		/// <b>NOTE:</b> you cannot call this method more than once for each search
 		/// execution. If you need to call it more than once, passing each time a
-		/// different <code>start</code>, you should call {@link #TopDocs()} and work
-		/// with the returned {@link TopDocs} object, which will contain all the
+		/// different <c>start</c>, you should call <see cref="TopDocs()" /> and work
+        /// with the returned <see cref="Lucene.Net.Search.TopDocs" /> object, which will contain all the
 		/// results this search execution collected.
 		/// </summary>
 		public TopDocs TopDocs(int start)
@@ -115,8 +115,8 @@ namespace Lucene.Net.Search
 		/// memory used by allocating only as much as requested by howMany.<br/>
 		/// <b>NOTE:</b> you cannot call this method more than once for each search
 		/// execution. If you need to call it more than once, passing each time a
-		/// different range, you should call {@link #TopDocs()} and work with the
-		/// returned {@link TopDocs} object, which will contain all the results this
+		/// different range, you should call <see cref="TopDocs()" /> and work with the
+        /// returned <see cref="Lucene.Net.Search.TopDocs" /> object, which will contain all the results this
 		/// search execution collected.
 		/// </summary>
 		public TopDocs TopDocs(int start, int howMany)

Modified: incubator/lucene.net/trunk/src/core/Search/TopFieldCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/TopFieldCollector.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/TopFieldCollector.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/TopFieldCollector.cs Sun Nov  6 05:24:26 2011
@@ -24,10 +24,10 @@ using Entry = Lucene.Net.Search.FieldVal
 namespace Lucene.Net.Search
 {
 	
-	/// <summary> A {@link Collector} that sorts by {@link SortField} using
-	/// {@link FieldComparator}s.
+	/// <summary> A <see cref="Collector" /> that sorts by <see cref="SortField" /> using
+	/// <see cref="FieldComparator" />s.
 	/// <p/>
-	/// See the {@link #create(Lucene.Net.Search.Sort, int, boolean, boolean, boolean, boolean)} method
+    /// See the <see cref="create(Lucene.Net.Search.Sort, int, bool, bool, bool, bool)" /> method
 	/// for instantiating a TopFieldCollector.
 	/// 
 	/// <p/><b>NOTE:</b> This API is experimental and might change in
@@ -976,12 +976,12 @@ namespace Lucene.Net.Search
 			this.fillFields = fillFields;
 		}
 		
-		/// <summary> Creates a new {@link TopFieldCollector} from the given
+		/// <summary> Creates a new <see cref="TopFieldCollector" /> from the given
 		/// arguments.
 		/// 
 		/// <p/><b>NOTE</b>: The instances returned by this method
 		/// pre-allocate a full array of length
-		/// <code>numHits</code>.
+		/// <c>numHits</c>.
 		/// 
 		/// </summary>
 		/// <param name="sort">the sort criteria (SortFields).
@@ -999,16 +999,16 @@ namespace Lucene.Net.Search
 		/// it is recommended to set it to false.
 		/// </param>
 		/// <param name="trackMaxScore">specifies whether the query's maxScore should be tracked and set
-		/// on the resulting {@link TopDocs}. Note that if set to false,
-		/// {@link TopDocs#GetMaxScore()} returns Float.NaN. Setting this to
+		/// on the resulting <see cref="TopDocs" />. Note that if set to false,
+		/// <see cref="TopDocs.GetMaxScore()" /> returns Float.NaN. Setting this to
 		/// true affects performance as it incurs the score computation on
 		/// each result. Also, setting this true automatically sets
-		/// <code>trackDocScores</code> to true as well.
+		/// <c>trackDocScores</c> to true as well.
 		/// </param>
 		/// <param name="docsScoredInOrder">specifies whether documents are scored in doc Id order or not by
-		/// the given {@link Scorer} in {@link #SetScorer(Scorer)}.
+		/// the given <see cref="Scorer" /> in <see cref="Collector.SetScorer(Scorer)" />.
 		/// </param>
-		/// <returns> a {@link TopFieldCollector} instance which will sort the results by
+		/// <returns> a <see cref="TopFieldCollector" /> instance which will sort the results by
 		/// the sort criteria.
 		/// </returns>
 		/// <throws>  IOException </throws>

Modified: incubator/lucene.net/trunk/src/core/Search/TopFieldDocCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/TopFieldDocCollector.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/TopFieldDocCollector.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/TopFieldDocCollector.cs Sun Nov  6 05:24:26 2011
@@ -22,16 +22,16 @@ using IndexReader = Lucene.Net.Index.Ind
 namespace Lucene.Net.Search
 {
 	
-	/// <summary>A {@link HitCollector} implementation that collects the top-sorting
-	/// documents, returning them as a {@link TopFieldDocs}.  This is used by {@link
-	/// IndexSearcher} to implement {@link TopFieldDocs}-based search.
+	/// <summary>A <see cref="HitCollector" /> implementation that collects the top-sorting
+	/// documents, returning them as a <see cref="TopFieldDocs" />.  This is used by <see cref="IndexSearcher" />
+	/// to implement <see cref="TopFieldDocs" />-based search.
 	/// 
 	/// <p/>This may be extended, overriding the collect method to, e.g.,
-	/// conditionally invoke <code>super()</code> in order to filter which
+	/// conditionally invoke <c>super()</c> in order to filter which
 	/// documents are collected.
 	/// 
 	/// </summary>
-	/// <deprecated> Please use {@link TopFieldCollector} instead.
+	/// <deprecated> Please use <see cref="TopFieldCollector" /> instead.
 	/// </deprecated>
     [Obsolete("Please use TopFieldCollector instead.")]
 	public class TopFieldDocCollector:TopDocCollector

Modified: incubator/lucene.net/trunk/src/core/Search/TopFieldDocs.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/TopFieldDocs.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/TopFieldDocs.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/TopFieldDocs.cs Sun Nov  6 05:24:26 2011
@@ -21,7 +21,7 @@ namespace Lucene.Net.Search
 {
 	
 	/// <summary>
-	/// Represents hits returned by {@link Searcher#search(Query,Filter,int,Sort)}.
+	/// Represents hits returned by <see cref="Searcher.Search(Query,Filter,int,Sort)" />.
 	/// </summary>
 	[Serializable]
 	public class TopFieldDocs:TopDocs

Modified: incubator/lucene.net/trunk/src/core/Search/TopScoreDocCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/TopScoreDocCollector.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/TopScoreDocCollector.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/TopScoreDocCollector.cs Sun Nov  6 05:24:26 2011
@@ -22,15 +22,15 @@ using IndexReader = Lucene.Net.Index.Ind
 namespace Lucene.Net.Search
 {
 	
-	/// <summary> A {@link Collector} implementation that collects the top-scoring hits,
-	/// returning them as a {@link TopDocs}. This is used by {@link IndexSearcher} to
-	/// implement {@link TopDocs}-based search. Hits are sorted by score descending
+	/// <summary> A <see cref="Collector" /> implementation that collects the top-scoring hits,
+	/// returning them as a <see cref="TopDocs" />. This is used by <see cref="IndexSearcher" /> to
+	/// implement <see cref="TopDocs" />-based search. Hits are sorted by score descending
 	/// and then (when the scores are tied) docID ascending. When you create an
 	/// instance of this collector you should know in advance whether documents are
 	/// going to be collected in doc Id order or not.
 	/// 
-	/// <p/><b>NOTE</b>: The values {@link Float#NaN} and
-    /// {Float#NEGATIVE_INFINITY} are not valid scores.  This
+	/// <p/><b>NOTE</b>: The values <see cref="float.NaN" /> and
+    /// <see cref="float.NegativeInfinity" /> are not valid scores.  This
     /// collector will not properly collect hits with such
     /// scores.
 	/// </summary>
@@ -102,13 +102,13 @@ namespace Lucene.Net.Search
 			}
 		}
 		
-		/// <summary> Creates a new {@link TopScoreDocCollector} given the number of hits to
+		/// <summary> Creates a new <see cref="TopScoreDocCollector" /> given the number of hits to
 		/// collect and whether documents are scored in order by the input
-		/// {@link Scorer} to {@link #SetScorer(Scorer)}.
+		/// <see cref="Scorer" /> to <see cref="SetScorer(Scorer)" />.
 		/// 
 		/// <p/><b>NOTE</b>: The instances returned by this method
 		/// pre-allocate a full array of length
-		/// <code>numHits</code>, and fill the array with sentinel
+		/// <c>numHits</c>, and fill the array with sentinel
 		/// objects.
 		/// </summary>
 		public static TopScoreDocCollector create(int numHits, bool docsScoredInOrder)

Modified: incubator/lucene.net/trunk/src/core/Search/Weight.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Weight.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Weight.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Weight.cs Sun Nov  6 05:24:26 2011
@@ -24,24 +24,24 @@ namespace Lucene.Net.Search
 	
 	/// <summary> Expert: Calculate query weights and build query scorers.
 	/// <p/>
-	/// The purpose of {@link Weight} is to ensure searching does not
-	/// modify a {@link Query}, so that a {@link Query} instance can be reused. <br/>
-	/// {@link Searcher} dependent state of the query should reside in the
-	/// {@link Weight}. <br/>
-	/// {@link IndexReader} dependent state should reside in the {@link Scorer}.
+	/// The purpose of <see cref="Weight" /> is to ensure searching does not
+	/// modify a <see cref="Query" />, so that a <see cref="Query" /> instance can be reused. <br/>
+	/// <see cref="Searcher" /> dependent state of the query should reside in the
+	/// <see cref="Weight" />. <br/>
+	/// <see cref="IndexReader" /> dependent state should reside in the <see cref="Scorer" />.
 	/// <p/>
-	/// A <code>Weight</code> is used in the following way:
-	/// <ol>
-	/// <li>A <code>Weight</code> is constructed by a top-level query, given a
-	/// <code>Searcher</code> ({@link Query#CreateWeight(Searcher)}).</li>
-	/// <li>The {@link #SumOfSquaredWeights()} method is called on the
-	/// <code>Weight</code> to compute the query normalization factor
-	/// {@link Similarity#QueryNorm(float)} of the query clauses contained in the
-	/// query.</li>
-	/// <li>The query normalization factor is passed to {@link #Normalize(float)}. At
-	/// this point the weighting is complete.</li>
-	/// <li>A <code>Scorer</code> is constructed by {@link #Scorer(IndexReader,boolean,boolean)}.</li>
-	/// </ol>
+	/// A <c>Weight</c> is used in the following way:
+	/// <list type="bullet">
+	/// <item>A <c>Weight</c> is constructed by a top-level query, given a
+	/// <c>Searcher</c> (<see cref="Query.CreateWeight(Searcher)" />).</item>
+	/// <item>The <see cref="SumOfSquaredWeights()" /> method is called on the
+	/// <c>Weight</c> to compute the query normalization factor
+	/// <see cref="Similarity.QueryNorm(float)" /> of the query clauses contained in the
+	/// query.</item>
+	/// <item>The query normalization factor is passed to <see cref="Normalize(float)" />. At
+	/// this point the weighting is complete.</item>
+    /// <item>A <c>Scorer</c> is constructed by <see cref="Scorer(IndexReader,bool,bool)" />.</item>
+	/// </list>
 	/// 
 	/// </summary>
 	/// <since> 2.9
@@ -71,35 +71,35 @@ namespace Lucene.Net.Search
 		/// <summary>Assigns the query normalization factor to this. </summary>
 		public abstract void  Normalize(float norm);
 		
-		/// <summary> Returns a {@link Scorer} which scores documents in/out-of order according
-		/// to <code>scoreDocsInOrder</code>.
+		/// <summary> Returns a <see cref="Scorer" /> which scores documents in/out-of order according
+		/// to <c>scoreDocsInOrder</c>.
 		/// <p/>
-		/// <b>NOTE:</b> even if <code>scoreDocsInOrder</code> is false, it is
-		/// recommended to check whether the returned <code>Scorer</code> indeed scores
-		/// documents out of order (i.e., call {@link #ScoresDocsOutOfOrder()}), as
-		/// some <code>Scorer</code> implementations will always return documents
+		/// <b>NOTE:</b> even if <c>scoreDocsInOrder</c> is false, it is
+		/// recommended to check whether the returned <c>Scorer</c> indeed scores
+		/// documents out of order (i.e., call <see cref="ScoresDocsOutOfOrder()" />), as
+		/// some <c>Scorer</c> implementations will always return documents
 		/// in-order.<br/>
 		/// <b>NOTE:</b> null can be returned if no documents will be scored by this
 		/// query.
 		/// 
 		/// </summary>
 		/// <param name="reader">
-		/// the {@link IndexReader} for which to return the {@link Scorer}.
+        /// the <see cref="IndexReader" /> for which to return the <see cref="Lucene.Net.Search.Scorer" />.
 		/// </param>
 		/// <param name="scoreDocsInOrder">specifies whether in-order scoring of documents is required. Note
 		/// that if set to false (i.e., out-of-order scoring is required),
 		/// this method can return whatever scoring mode it supports, as every
 		/// in-order scorer is also an out-of-order one. However, an
-		/// out-of-order scorer may not support {@link Scorer#NextDoc()}
-		/// and/or {@link Scorer#Advance(int)}, therefore it is recommended to
+        /// out-of-order scorer may not support <see cref="DocIdSetIterator.NextDoc" />
+        /// and/or <see cref="DocIdSetIterator.Advance(int)" />, therefore it is recommended to
 		/// request an in-order scorer if use of these methods is required.
 		/// </param>
 		/// <param name="topScorer">
-		/// if true, {@link Scorer#Score(Collector)} will be called; if false,
-		/// {@link Scorer#NextDoc()} and/or {@link Scorer#Advance(int)} will
+        /// if true, <see cref="Lucene.Net.Search.Scorer.Score(Lucene.Net.Search.Collector)" /> will be called; if false,
+        /// <see cref="DocIdSetIterator.NextDoc" /> and/or <see cref="DocIdSetIterator.Advance(int)" /> will
 		/// be called.
 		/// </param>
-		/// <returns> a {@link Scorer} which scores documents in/out-of order.
+		/// <returns> a <see cref="Scorer" /> which scores documents in/out-of order.
 		/// </returns>
 		/// <throws>  IOException </throws>
 		public abstract Scorer Scorer(IndexReader reader, bool scoreDocsInOrder, bool topScorer);
@@ -108,14 +108,14 @@ namespace Lucene.Net.Search
 		public abstract float SumOfSquaredWeights();
 		
 		/// <summary> Returns true iff this implementation scores docs only out of order. This
-		/// method is used in conjunction with {@link Collector}'s
-		/// {@link Collector#AcceptsDocsOutOfOrder() acceptsDocsOutOfOrder} and
-		/// {@link #Scorer(Lucene.Net.Index.IndexReader, boolean, boolean)} to
-		/// create a matching {@link Scorer} instance for a given {@link Collector}, or
+		/// method is used in conjunction with <see cref="Collector" />'s 
+        /// <see cref="Collector.AcceptsDocsOutOfOrder()">AcceptsDocsOutOfOrder</see> and
+        /// <see cref="Scorer(Lucene.Net.Index.IndexReader, bool, bool)" /> to
+		/// create a matching <see cref="Scorer" /> instance for a given <see cref="Collector" />, or
 		/// vice versa.
 		/// <p/>
-		/// <b>NOTE:</b> the default implementation returns <code>false</code>, i.e.
-		/// the <code>Scorer</code> scores documents in-order.
+		/// <b>NOTE:</b> the default implementation returns <c>false</c>, i.e.
+		/// the <c>Scorer</c> scores documents in-order.
 		/// </summary>
 		public virtual bool ScoresDocsOutOfOrder()
 		{

Modified: incubator/lucene.net/trunk/src/core/Search/WildcardQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/WildcardQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/WildcardQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/WildcardQuery.cs Sun Nov  6 05:24:26 2011
@@ -24,15 +24,15 @@ using ToStringUtils = Lucene.Net.Util.To
 namespace Lucene.Net.Search
 {
 	
-	/// <summary>Implements the wildcard search query. Supported wildcards are <code>*</code>, which
-	/// matches any character sequence (including the empty one), and <code>?</code>,
+	/// <summary>Implements the wildcard search query. Supported wildcards are <c>*</c>, which
+	/// matches any character sequence (including the empty one), and <c>?</c>,
 	/// which matches any single character. Note this query can be slow, as it
 	/// needs to iterate over many terms. In order to prevent extremely slow WildcardQueries,
-	/// a Wildcard term should not start with one of the wildcards <code>*</code> or
-	/// <code>?</code>.
+	/// a Wildcard term should not start with one of the wildcards <c>*</c> or
+	/// <c>?</c>.
 	/// 
-	/// <p/>This query uses the {@link
-	/// MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}
+	/// <p/>This query uses the <see cref="MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT" />
+	///
 	/// rewrite method.
 	/// 
 	/// </summary>

Modified: incubator/lucene.net/trunk/src/core/Search/WildcardTermEnum.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/WildcardTermEnum.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/WildcardTermEnum.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/WildcardTermEnum.cs Sun Nov  6 05:24:26 2011
@@ -41,7 +41,7 @@ namespace Lucene.Net.Search
 		internal int preLen;
 		internal bool endEnum = false;
 		
-		/// <summary> Creates a new <code>WildcardTermEnum</code>.
+		/// <summary> Creates a new <c>WildcardTermEnum</c>.
 		/// <p/>
 		/// After calling the constructor the enumeration is already pointing to the first 
 		/// valid term if such a term exists.

Modified: incubator/lucene.net/trunk/src/core/Store/BufferedIndexInput.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/BufferedIndexInput.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/BufferedIndexInput.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/BufferedIndexInput.cs Sun Nov  6 05:24:26 2011
@@ -20,7 +20,7 @@ using System;
 namespace Lucene.Net.Store
 {
 	
-	/// <summary>Base implementation class for buffered {@link IndexInput}. </summary>
+	/// <summary>Base implementation class for buffered <see cref="IndexInput" />. </summary>
 	public abstract class BufferedIndexInput:IndexInput, System.ICloneable
 	{
 		
@@ -88,7 +88,7 @@ namespace Lucene.Net.Store
 			buffer = newBuffer;
 		}
 		
-		/// <seealso cref="setBufferSize">
+		/// <seealso cref="SetBufferSize">
 		/// </seealso>
 		public virtual int GetBufferSize()
 		{
@@ -220,7 +220,7 @@ namespace Lucene.Net.Store
 		}
 		
 		/// <summary>Expert: implements seek.  Sets current position in this file, where the
-		/// next {@link #ReadInternal(byte[],int,int)} will occur.
+		/// next <see cref="ReadInternal(byte[],int,int)" /> will occur.
 		/// </summary>
 		/// <seealso cref="ReadInternal(byte[],int,int)">
 		/// </seealso>

Modified: incubator/lucene.net/trunk/src/core/Store/BufferedIndexOutput.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/BufferedIndexOutput.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/BufferedIndexOutput.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/BufferedIndexOutput.cs Sun Nov  6 05:24:26 2011
@@ -20,7 +20,7 @@ using System;
 namespace Lucene.Net.Store
 {
 	
-	/// <summary>Base implementation class for buffered {@link IndexOutput}. </summary>
+	/// <summary>Base implementation class for buffered <see cref="IndexOutput" />. </summary>
 	public abstract class BufferedIndexOutput:IndexOutput
 	{
 		internal const int BUFFER_SIZE = 16384;

Modified: incubator/lucene.net/trunk/src/core/Store/CheckSumIndexOutput.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/CheckSumIndexOutput.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/CheckSumIndexOutput.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/CheckSumIndexOutput.cs Sun Nov  6 05:24:26 2011
@@ -76,8 +76,8 @@ namespace Lucene.Net.Store
 		
 		/// <summary> Starts but does not complete the commit of this file (=
 		/// writing of the final checksum at the end).  After this
-		/// is called must call {@link #finishCommit} and the
-		/// {@link #close} to complete the commit.
+		/// is called must call <see cref="FinishCommit" /> and the
+		/// <see cref="Close" /> to complete the commit.
 		/// </summary>
 		public virtual void  PrepareCommit()
 		{
@@ -93,7 +93,7 @@ namespace Lucene.Net.Store
 			main.Seek(pos);
 		}
 		
-		/// <summary>See {@link #prepareCommit} </summary>
+		/// <summary>See <see cref="PrepareCommit" /> </summary>
 		public virtual void  FinishCommit()
 		{
 			main.WriteLong(GetChecksum());

Modified: incubator/lucene.net/trunk/src/core/Store/Directory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/Directory.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/Directory.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/Directory.cs Sun Nov  6 05:24:26 2011
@@ -27,15 +27,15 @@ namespace Lucene.Net.Store
 	/// deleted.  Random access is permitted both when reading and writing.
 	/// 
 	/// <p/> Java's i/o APIs not used directly, but rather all i/o is
-	/// through this API.  This permits things such as: <ul>
-	/// <li> implementation of RAM-based indices;</li>
-	/// <li> implementation indices stored in a database, via JDBC;</li>
-	/// <li> implementation of an index as a single file;</li>
-	/// </ul>
+	/// through this API.  This permits things such as: <list>
+	/// <item> implementation of RAM-based indices;</item>
+	/// <item> implementation indices stored in a database, via JDBC;</item>
+	/// <item> implementation of an index as a single file;</item>
+	/// </list>
 	/// 
-	/// Directory locking is implemented by an instance of {@link
-	/// LockFactory}, and can be changed for each Directory
-	/// instance using {@link #setLockFactory}.
+	/// Directory locking is implemented by an instance of <see cref="LockFactory" />
+	///, and can be changed for each Directory
+	/// instance using <see cref="SetLockFactory" />.
 	/// 
 	/// </summary>
 	[Serializable]
@@ -49,22 +49,22 @@ namespace Lucene.Net.Store
 		[NonSerialized]
 		protected internal LockFactory lockFactory;
 		
-		/// <deprecated> For some Directory implementations ({@link
-		/// FSDirectory}, and its subclasses), this method
+		/// <deprecated> For some Directory implementations (<see cref="FSDirectory" />
+		///, and its subclasses), this method
 		/// silently filters its results to include only index
-		/// files.  Please use {@link #listAll} instead, which
+		/// files.  Please use <see cref="ListAll" /> instead, which
 		/// does no filtering. 
 		/// </deprecated>
         [Obsolete("For some Directory implementations (FSDirectory}, and its subclasses), this method silently filters its results to include only index files.  Please use ListAll instead, which does no filtering. ")]
 		public abstract System.String[] List();
 		
 		/// <summary>Returns an array of strings, one for each file in the
-		/// directory.  Unlike {@link #list} this method does no
+		/// directory.  Unlike <see cref="List" /> this method does no
 		/// filtering of the contents in a directory, and it will
 		/// never return null (throws IOException instead).
 		/// 
-		/// Currently this method simply fallsback to {@link
-		/// #list} for Directory impls outside of Lucene's core &amp;
+		/// Currently this method simply fallsback to <see cref="List" />
+		/// for Directory impls outside of Lucene's core &amp;
 		/// contrib, but in 3.0 that method will be removed and
 		/// this method will become abstract. 
 		/// </summary>
@@ -119,15 +119,15 @@ namespace Lucene.Net.Store
 		/// specified read buffer size.  The particular Directory
 		/// implementation may ignore the buffer size.  Currently
 		/// the only Directory implementations that respect this
-		/// parameter are {@link FSDirectory} and {@link
-		/// Lucene.Net.Index.CompoundFileReader}.
+		/// parameter are <see cref="FSDirectory" /> and <see cref="Lucene.Net.Index.CompoundFileReader" />
+		///.
 		/// </summary>
 		public virtual IndexInput OpenInput(System.String name, int bufferSize)
 		{
 			return OpenInput(name);
 		}
 		
-		/// <summary>Construct a {@link Lock}.</summary>
+		/// <summary>Construct a <see cref="Lock" />.</summary>
 		/// <param name="name">the name of the lock file
 		/// </param>
 		public virtual Lock MakeLock(System.String name)
@@ -160,7 +160,7 @@ namespace Lucene.Net.Store
 		/// Directories).
 		/// 
 		/// </summary>
-		/// <param name="lockFactory">instance of {@link LockFactory}.
+		/// <param name="lockFactory">instance of <see cref="LockFactory" />.
 		/// </param>
 		public virtual void  SetLockFactory(LockFactory lockFactory)
 		{
@@ -213,7 +213,7 @@ namespace Lucene.Net.Store
 		/// </param>
 		/// <param name="dest">destination directory
 		/// </param>
-		/// <param name="closeDirSrc">if <code>true</code>, call {@link #Close()} method on source directory
+		/// <param name="closeDirSrc">if <c>true</c>, call <see cref="Close()" /> method on source directory
 		/// </param>
 		/// <throws>  IOException </throws>
 		public static void  Copy(Directory src, Directory dest, bool closeDirSrc)



Mime
View raw message