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 [16/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/Store/FSDirectory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/FSDirectory.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/FSDirectory.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/FSDirectory.cs Sun Nov  6 05:24:26 2011
@@ -31,30 +31,30 @@ namespace Lucene.Net.Store
 	/// files in the file system.  There are currently three core
 	/// subclasses:
 	/// 
-	/// <ul>
+	/// <list type="bullet">
 	/// 
-	/// <li> {@link SimpleFSDirectory} is a straightforward
+	/// <item> <see cref="SimpleFSDirectory" /> is a straightforward
 	/// implementation using java.io.RandomAccessFile.
 	/// However, it has poor concurrent performance
 	/// (multiple threads will bottleneck) as it
 	/// synchronizes when multiple threads read from the
-	/// same file.</li>
+	/// same file.</item>
 	/// 
-	/// <li> {@link NIOFSDirectory} uses java.nio's
+	/// <item> <see cref="NIOFSDirectory" /> uses java.nio's
 	/// FileChannel's positional io when reading to avoid
 	/// synchronization when reading from the same file.
 	/// Unfortunately, due to a Windows-only <a
 	/// href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6265734">Sun
 	/// JRE bug</a> this is a poor choice for Windows, but
 	/// on all other platforms this is the preferred
-	/// choice. Applications using {@link Thread#interrupt()} or
-    /// <code>Future#cancel(boolean)</code> (on Java 1.5) should use
-    /// {@link SimpleFSDirectory} instead. See {@link NIOFSDirectory} java doc
+	/// choice. Applications using <see cref="System.Threading.Thread.Interrupt()" /> or
+    /// <c>Future#cancel(boolean)</c> (on Java 1.5) should use
+    /// <see cref="SimpleFSDirectory" /> instead. See <see cref="NIOFSDirectory" /> java doc
     /// for details.
     ///        
     ///        
 	/// 
-	/// <li> {@link MMapDirectory} uses memory-mapped IO when
+	/// <item> <see cref="MMapDirectory" /> uses memory-mapped IO when
 	/// reading. This is a good choice if you have plenty
 	/// of virtual memory relative to your index size, eg
 	/// if you are running on a 64 bit JRE, or you are
@@ -64,7 +64,7 @@ namespace Lucene.Net.Store
 	/// unmap files from user code. The files are unmapped, when GC
 	/// releases the byte buffers. Due to
 	/// <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4724038">
-	/// this bug</a> in Sun's JRE, MMapDirectory's {@link IndexInput#close}
+	/// this bug</a> in Sun's JRE, MMapDirectory's <see cref="IndexInput.Close" />
 	/// is unable to close the underlying OS file handle. Only when
 	/// GC finally collects the underlying objects, which could be
 	/// quite some time later, will the file handle be closed.
@@ -77,38 +77,38 @@ namespace Lucene.Net.Store
 	/// and you don't rely on overwriting files on Windows) but it's still
 	/// an important limitation to be aware of. This class supplies a
 	/// (possibly dangerous) workaround mentioned in the bug report,
-	/// which may fail on non-Sun JVMs.</li>
+	/// which may fail on non-Sun JVMs.</item>
     ///       
-    /// Applications using {@link Thread#interrupt()} or
-    /// <code>Future#cancel(boolean)</code> (on Java 1.5) should use
-    /// {@link SimpleFSDirectory} instead. See {@link MMapDirectory}
-    /// java doc for details.
-	/// </ul>
+    /// Applications using <see cref="System.Threading.Thread.Interrupt()" /> or
+    /// <c>Future#cancel(boolean)</c> (on Java 1.5) should use
+    /// <see cref="SimpleFSDirectory" /> instead. See <see cref="MMapDirectory" />
+    /// java doc for details.</item>
+	/// </list>
 	/// 
 	/// Unfortunately, because of system peculiarities, there is
 	/// no single overall best implementation.  Therefore, we've
-	/// added the {@link #open} method, to allow Lucene to choose
+	/// added the <see cref="Open(System.IO.DirectoryInfo)" /> method, to allow Lucene to choose
 	/// the best FSDirectory implementation given your
 	/// environment, and the known limitations of each
 	/// implementation.  For users who have no reason to prefer a
-	/// specific implementation, it's best to simply use {@link
-	/// #open}.  For all others, you should instantiate the
+	/// specific implementation, it's best to simply use <see cref="FSDirectory.Open(System.IO.DirectoryInfo)" />
+	///.  For all others, you should instantiate the
 	/// desired implementation directly.
 	/// 
-	/// <p/>The locking implementation is by default {@link
-	/// NativeFSLockFactory}, but can be changed by
-	/// passing in a custom {@link LockFactory} instance.
-	/// The deprecated <code>getDirectory</code> methods default to use
-	/// {@link SimpleFSLockFactory} for backwards compatibility.
+	/// <p/>The locking implementation is by default <see cref="NativeFSLockFactory" />
+	///, but can be changed by
+	/// passing in a custom <see cref="LockFactory" /> instance.
+	/// The deprecated <c>getDirectory</c> methods default to use
+	/// <see cref="SimpleFSLockFactory" /> for backwards compatibility.
 	/// The system properties 
-	/// <code>org.apache.lucene.store.FSDirectoryLockFactoryClass</code>
-	/// and <code>org.apache.lucene.FSDirectory.class</code>
+	/// <c>org.apache.lucene.store.FSDirectoryLockFactoryClass</c>
+	/// and <c>org.apache.lucene.FSDirectory.class</c>
 	/// are deprecated and only used by the deprecated
-	/// <code>getDirectory</code> methods. The system property
-	/// <code>org.apache.lucene.lockDir</code> is ignored completely,
+	/// <c>getDirectory</c> methods. The system property
+	/// <c>org.apache.lucene.lockDir</c> is ignored completely,
 	/// If you really want to store locks
-	/// elsewhere, you can create your own {@link
-	/// SimpleFSLockFactory} (or {@link NativeFSLockFactory},
+	/// elsewhere, you can create your own <see cref="SimpleFSLockFactory" />
+	/// (or <see cref="NativeFSLockFactory" />,
 	/// etc.) passing in your preferred lock directory.
 	/// 
 	/// <p/><em>In 3.0 this class will become abstract.</em>
@@ -142,13 +142,13 @@ namespace Lucene.Net.Store
 		/// lock files are enabled. They should only be disabled if the index
 		/// is on a read-only medium like a CD-ROM.
 		/// </summary>
-		/// <deprecated> Use a {@link #open(File, LockFactory)} or a constructor
-		/// that takes a {@link LockFactory} and supply
-		/// {@link NoLockFactory#getNoLockFactory}. This setting does not work
-		/// with {@link #open(File)} only the deprecated <code>getDirectory</code>
+        /// <deprecated> Use a <see cref="Open(System.IO.DirectoryInfo, LockFactory)" /> or a constructor
+		/// that takes a <see cref="LockFactory" /> and supply
+		/// <see cref="NoLockFactory.GetNoLockFactory" />. This setting does not work
+        /// with <see cref="Open(System.IO.DirectoryInfo)" /> only the deprecated <c>getDirectory</c>
 		/// respect this setting.   
 		/// </deprecated>
-        [Obsolete("Use a Open(File, LockFactory) or a constructor that takes a LockFactory and supply NoLockFactory.GetNoLockFactory. This setting does not work with Open(File) only the deprecated GetDirectory respect this setting.")]
+        [Obsolete("Use a Open(System.IO.DirectoryInfo, LockFactory) or a constructor that takes a LockFactory and supply NoLockFactory.GetNoLockFactory. This setting does not work with Open(File) only the deprecated GetDirectory respect this setting.")]
 		public static void  SetDisableLocks(bool doDisableLocks)
 		{
 			FSDirectory.disableLocks = doDisableLocks;
@@ -157,10 +157,10 @@ namespace Lucene.Net.Store
 		/// <summary> Returns whether Lucene's use of lock files is disabled.</summary>
 		/// <returns> true if locks are disabled, false if locks are enabled.
 		/// </returns>
-		/// <seealso cref="setDisableLocks">
+		/// <seealso cref="SetDisableLocks">
 		/// </seealso>
-		/// <deprecated> Use a constructor that takes a {@link LockFactory} and
-		/// supply {@link NoLockFactory#getNoLockFactory}.
+		/// <deprecated> Use a constructor that takes a <see cref="LockFactory" /> and
+		/// supply <see cref="NoLockFactory.GetNoLockFactory" />.
 		/// </deprecated>
         [Obsolete("Use a constructor that takes a LockFactory and supply NoLockFactory.GetNoLockFactory.")]
 		public static bool GetDisableLocks()
@@ -168,19 +168,19 @@ namespace Lucene.Net.Store
 			return FSDirectory.disableLocks;
 		}
 		
-		/// <summary> Directory specified by <code>org.apache.lucene.lockDir</code>
-		/// or <code>java.io.tmpdir</code> system property.
-		/// </summary>
-		/// <deprecated> As of 2.1, <code>LOCK_DIR</code> is unused
-		/// because the write.lock is now stored by default in the
-		/// index directory.  If you really want to store locks
-		/// elsewhere, you can create your own {@link
-		/// SimpleFSLockFactory} (or {@link NativeFSLockFactory},
-		/// etc.) passing in your preferred lock directory.  Then,
-		/// pass this <code>LockFactory</code> instance to one of
-		/// the <code>open</code> methods that take a
-		/// <code>lockFactory</code> (for example, {@link #open(File, LockFactory)}).
-		/// </deprecated>
+        ///// <summary> Directory specified by <c>org.apache.lucene.lockDir</c>
+        ///// or <c>java.io.tmpdir</c> system property.
+        ///// </summary>
+        ///// <deprecated> As of 2.1, <c>LOCK_DIR</c> is unused
+        ///// because the write.lock is now stored by default in the
+        ///// index directory.  If you really want to store locks
+        ///// elsewhere, you can create your own <see cref="// SimpleFSLockFactory" />
+        ///// (or <see cref="NativeFSLockFactory" />,
+        ///// etc.) passing in your preferred lock directory.  Then,
+        ///// pass this <c>LockFactory</c> instance to one of
+        ///// the <c>open</c> methods that take a
+        ///// <c>lockFactory</c> (for example, <see cref="Open(System.IO.DirectoryInfo, LockFactory)" />).
+        ///// </deprecated>
         //[Obsolete("As of 2.1, LOCK_DIR is unused because the write.lock is now stored by default in the index directory. ")]
 		//public static readonly System.String LOCK_DIR = SupportClass.AppSettings.Get("Lucene.Net.lockDir", System.IO.Path.GetTempPath());
 		
@@ -198,14 +198,14 @@ namespace Lucene.Net.Store
 		/// <summary>Returns the directory instance for the named location.
 		/// 
 		/// </summary>
-		/// <deprecated> Use {@link #Open(File)}
+        /// <deprecated> Use <see cref="Open(System.IO.DirectoryInfo)" />
 		/// 
 		/// </deprecated>
 		/// <param name="path">the path to the directory.
 		/// </param>
 		/// <returns> the FSDirectory for the named file.  
 		/// </returns>
-        [Obsolete("Use Open(File)")]
+        [Obsolete("Use Open(System.IO.DirectoryInfo)")]
 		public static FSDirectory GetDirectory(System.String path)
 		{
 			return GetDirectory(new System.IO.DirectoryInfo(path), null);
@@ -214,12 +214,12 @@ namespace Lucene.Net.Store
 		/// <summary>Returns the directory instance for the named location.
 		/// 
 		/// </summary>
-		/// <deprecated> Use {@link #Open(File, LockFactory)}
+        /// <deprecated> Use <see cref="Open(System.IO.DirectoryInfo, LockFactory)" />
 		/// 
 		/// </deprecated>
 		/// <param name="path">the path to the directory.
 		/// </param>
-		/// <param name="lockFactory">instance of {@link LockFactory} providing the
+		/// <param name="lockFactory">instance of <see cref="LockFactory" /> providing the
 		/// locking implementation.
 		/// </param>
 		/// <returns> the FSDirectory for the named file.  
@@ -233,7 +233,7 @@ namespace Lucene.Net.Store
 		/// <summary>Returns the directory instance for the named location.
 		/// 
 		/// </summary>
-		/// <deprecated> Use {@link #Open(File)}
+        /// <deprecated> Use <see cref="Open(System.IO.DirectoryInfo)" />
 		/// 
 		/// </deprecated>
 		/// <param name="file">the path to the directory.
@@ -249,7 +249,7 @@ namespace Lucene.Net.Store
         /// <summary>Returns the directory instance for the named location.
         /// 
         /// </summary>
-        /// <deprecated> Use {@link #Open(File)}
+        /// <deprecated> Use <see cref="Open(System.IO.DirectoryInfo)" />
         /// 
         /// </deprecated>
         /// <param name="file">the path to the directory.
@@ -265,12 +265,12 @@ namespace Lucene.Net.Store
 		/// <summary>Returns the directory instance for the named location.
 		/// 
 		/// </summary>
-		/// <deprecated> Use {@link #Open(File, LockFactory)}
+        /// <deprecated> Use <see cref="Open(System.IO.DirectoryInfo, LockFactory)" />
 		/// 
 		/// </deprecated>
 		/// <param name="file">the path to the directory.
 		/// </param>
-		/// <param name="lockFactory">instance of {@link LockFactory} providing the
+		/// <param name="lockFactory">instance of <see cref="LockFactory" /> providing the
 		/// locking implementation.
 		/// </param>
 		/// <returns> the FSDirectory for the named file.  
@@ -284,12 +284,12 @@ namespace Lucene.Net.Store
         /// <summary>Returns the directory instance for the named location.
         /// 
         /// </summary>
-        /// <deprecated> Use {@link #Open(File, LockFactory)}
+        /// <deprecated> Use <see cref="Open(System.IO.DirectoryInfo, LockFactory)" />
         /// 
         /// </deprecated>
         /// <param name="file">the path to the directory.
         /// </param>
-        /// <param name="lockFactory">instance of {@link LockFactory} providing the
+        /// <param name="lockFactory">instance of <see cref="LockFactory" /> providing the
         /// locking implementation.
         /// </param>
         /// <returns> the FSDirectory for the named file.  
@@ -449,7 +449,7 @@ namespace Lucene.Net.Store
 		}
 		
 		/// <summary>Initializes the directory to create a new file with the given name.
-		/// This method should be used in {@link #createOutput}. 
+		/// This method should be used in <see cref="CreateOutput" />. 
 		/// </summary>
 		protected internal void  InitOutput(System.String name)
 		{
@@ -489,7 +489,7 @@ namespace Lucene.Net.Store
 		/// <param name="path">the path of the directory
 		/// </param>
 		/// <param name="lockFactory">the lock factory to use, or null for the default
-		/// ({@link NativeFSLockFactory});
+		/// (<see cref="NativeFSLockFactory" />);
 		/// </param>
 		/// <throws>  IOException </throws>
 		protected internal FSDirectory(System.IO.DirectoryInfo path, LockFactory lockFactory)
@@ -505,12 +505,12 @@ namespace Lucene.Net.Store
 		
 		/// <summary>Creates an FSDirectory instance, trying to pick the
 		/// best implementation given the current environment.
-		/// The directory returned uses the {@link NativeFSLockFactory}.
+		/// The directory returned uses the <see cref="NativeFSLockFactory" />.
         /// 
-        /// <p/>Currently this returns {@link SimpleFSDirectory} as
+        /// <p/>Currently this returns <see cref="SimpleFSDirectory" /> as
         /// NIOFSDirectory is currently not supported.
 		/// 
-		/// <p/>Currently this returns {@link SimpleFSDirectory} as
+		/// <p/>Currently this returns <see cref="SimpleFSDirectory" /> as
 		/// NIOFSDirectory is currently not supported.
 		/// 
 		/// <p/><b>NOTE</b>: this method may suddenly change which
@@ -519,7 +519,7 @@ namespace Lucene.Net.Store
 		/// possible; if the precise implementation is important to
 		/// your application, please instantiate it directly,
 		/// instead. On 64 bit systems, it may also good to
-		/// return {@link MMapDirectory}, but this is disabled
+		/// return <see cref="MMapDirectory" />, but this is disabled
 		/// because of officially missing unmap support in Java.
 		/// For optimal performance you should consider using
 		/// this implementation on 64 bit JVMs.
@@ -535,9 +535,9 @@ namespace Lucene.Net.Store
 		
 		/// <summary>Creates an FSDirectory instance, trying to pick the
 		/// best implementation given the current environment.
-		/// The directory returned uses the {@link NativeFSLockFactory}.
+		/// The directory returned uses the <see cref="NativeFSLockFactory" />.
 		/// 
-		/// <p/>Currently this returns {@link SimpleFSDirectory} as
+		/// <p/>Currently this returns <see cref="SimpleFSDirectory" /> as
 		/// NIOFSDirectory is currently not supported.
 		/// 
 		/// <p/><b>NOTE</b>: this method may suddenly change which
@@ -546,7 +546,7 @@ namespace Lucene.Net.Store
 		/// possible; if the precise implementation is important to
 		/// your application, please instantiate it directly,
 		/// instead. On 64 bit systems, it may also good to
-		/// return {@link MMapDirectory}, but this is disabled
+		/// return <see cref="MMapDirectory" />, but this is disabled
 		/// because of officially missing unmap support in Java.
 		/// For optimal performance you should consider using
 		/// this implementation on 64 bit JVMs.
@@ -557,9 +557,9 @@ namespace Lucene.Net.Store
 		{
 			return Open(path, null);
 		}
-		
-		/// <summary>Just like {@link #Open(File)}, but allows you to
-		/// also specify a custom {@link LockFactory}. 
+
+        /// <summary>Just like <see cref="Open(System.IO.DirectoryInfo)" />, but allows you to
+		/// also specify a custom <see cref="LockFactory" />. 
 		/// </summary>
 		public static FSDirectory Open(System.IO.DirectoryInfo path, LockFactory lockFactory)
 		{
@@ -672,7 +672,7 @@ namespace Lucene.Net.Store
 		
 		/// <summary>Lists all files (not subdirectories) in the
 		/// directory.  This method never returns null (throws
-		/// {@link IOException} instead).
+		/// <see cref="System.IO.IOException" /> instead).
 		/// 
 		/// </summary>
 		/// <throws>  NoSuchDirectoryException if the directory </throws>
@@ -688,7 +688,7 @@ namespace Lucene.Net.Store
 		
         /// <summary>Lists all files (not subdirectories) in the
         /// directory.  This method never returns null (throws
-        /// {@link IOException} instead).
+        /// <see cref="System.IO.IOException" /> instead).
         /// 
         /// </summary>
         /// <throws>  NoSuchDirectoryException if the directory </throws>
@@ -727,7 +727,7 @@ namespace Lucene.Net.Store
 		/// <summary>Lists all files (not subdirectories) in the
 		/// directory.
 		/// </summary>
-		/// <seealso cref="ListAll(File)">
+		/// <seealso cref="ListAll(System.IO.DirectoryInfo)">
 		/// </seealso>
 		public override System.String[] ListAll()
 		{
@@ -968,9 +968,9 @@ namespace Lucene.Net.Store
 		
 		/// <summary> Default read chunk size.  This is a conditional
 		/// default: on 32bit JVMs, it defaults to 100 MB.  On
-		/// 64bit JVMs, it's <code>Integer.MAX_VALUE</code>.
+		/// 64bit JVMs, it's <c>Integer.MAX_VALUE</c>.
 		/// </summary>
-		/// <seealso cref="setReadChunkSize">
+		/// <seealso cref="SetReadChunkSize">
 		/// </seealso>
 		public static readonly int DEFAULT_READ_CHUNK_SIZE;
 		
@@ -978,8 +978,8 @@ namespace Lucene.Net.Store
 		private int chunkSize = DEFAULT_READ_CHUNK_SIZE;
 		
 		/// <summary> Sets the maximum number of bytes read at once from the
-		/// underlying file during {@link IndexInput#readBytes}.
-		/// The default value is {@link #DEFAULT_READ_CHUNK_SIZE};
+		/// underlying file during <see cref="IndexInput.ReadBytes(byte[], int, int)" />.
+		/// The default value is <see cref="DEFAULT_READ_CHUNK_SIZE" />;
 		/// 
 		/// <p/> This was introduced due to <a
 		/// href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6478546">Sun
@@ -989,7 +989,7 @@ namespace Lucene.Net.Store
 		/// maximum heap size.<p/>
 		/// 
 		/// <p/>Changes to this value will not impact any
-		/// already-opened {@link IndexInput}s.  You should call
+		/// already-opened <see cref="IndexInput" />s.  You should call
 		/// this before attempting to open an index on the
 		/// directory.<p/>
 		/// 
@@ -1012,9 +1012,9 @@ namespace Lucene.Net.Store
 		}
 		
 		/// <summary> The maximum number of bytes to read at once from the
-		/// underlying file during {@link IndexInput#readBytes}.
+		/// underlying file during <see cref="IndexInput.ReadBytes(byte[],int,int)" />.
 		/// </summary>
-		/// <seealso cref="setReadChunkSize">
+		/// <seealso cref="SetReadChunkSize">
 		/// </seealso>
 		public int GetReadChunkSize()
 		{

Modified: incubator/lucene.net/trunk/src/core/Store/FSLockFactory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/FSLockFactory.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/FSLockFactory.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/FSLockFactory.cs Sun Nov  6 05:24:26 2011
@@ -29,7 +29,7 @@ namespace Lucene.Net.Store
 		protected internal System.IO.DirectoryInfo lockDir = null;
 		
 		/// <summary> Set the lock directory. This method can be only called
-		/// once to initialize the lock directory. It is used by {@link FSDirectory}
+		/// once to initialize the lock directory. It is used by <see cref="FSDirectory" />
 		/// to set the lock directory to itsself.
 		/// Subclasses can also use this method to set the directory
 		/// in the constructor.

Modified: incubator/lucene.net/trunk/src/core/Store/IndexInput.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/IndexInput.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/IndexInput.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/IndexInput.cs Sun Nov  6 05:24:26 2011
@@ -20,7 +20,7 @@ using System;
 namespace Lucene.Net.Store
 {
 	
-	/// <summary>Abstract base class for input from a file in a {@link Directory}.  A
+	/// <summary>Abstract base class for input from a file in a <see cref="Directory" />.  A
 	/// random-access input stream.  Used for all Lucene index input operations.
 	/// </summary>
 	/// <seealso cref="Directory">
@@ -49,7 +49,7 @@ namespace Lucene.Net.Store
 		/// specified offset with control over whether the read
 		/// should be buffered (callers who have their own buffer
 		/// should pass in "false" for useBuffer).  Currently only
-		/// {@link BufferedIndexInput} respects this parameter.
+		/// <see cref="BufferedIndexInput" /> respects this parameter.
 		/// </summary>
 		/// <param name="b">the array to read bytes into
 		/// </param>
@@ -184,8 +184,8 @@ namespace Lucene.Net.Store
 		
 		/// <summary> Expert
 		/// 
-		/// Similar to {@link #ReadChars(char[], int, int)} but does not do any conversion operations on the bytes it is reading in.  It still
-		/// has to invoke {@link #ReadByte()} just as {@link #ReadChars(char[], int, int)} does, but it does not need a buffer to store anything
+		/// Similar to <see cref="ReadChars(char[], int, int)" /> but does not do any conversion operations on the bytes it is reading in.  It still
+		/// has to invoke <see cref="ReadByte()" /> just as <see cref="ReadChars(char[], int, int)" /> does, but it does not need a buffer to store anything
 		/// and it does not have to do any of the bitwise operations, since we don't actually care what is in the byte except to determine
 		/// how many more bytes to read
 		/// </summary>

Modified: incubator/lucene.net/trunk/src/core/Store/IndexOutput.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/IndexOutput.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/IndexOutput.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/IndexOutput.cs Sun Nov  6 05:24:26 2011
@@ -132,7 +132,7 @@ namespace Lucene.Net.Store
 		/// <param name="length">the number of characters in the sequence
 		/// </param>
 		/// <deprecated> -- please pre-convert to utf8 bytes
-		/// instead or use {@link #writeString}
+		/// instead or use <see cref="WriteString" />
 		/// </deprecated>
         [Obsolete("-- please pre-convert to utf8 bytes instead or use WriteString")]
 		public virtual void  WriteChars(System.String s, int start, int length)
@@ -166,7 +166,7 @@ namespace Lucene.Net.Store
 		/// </param>
 		/// <param name="length">the number of characters in the sequence
 		/// </param>
-		/// <deprecated> -- please pre-convert to utf8 bytes instead or use {@link #writeString}
+		/// <deprecated> -- please pre-convert to utf8 bytes instead or use <see cref="WriteString" />
 		/// </deprecated>
         [Obsolete("-- please pre-convert to utf8 bytes instead or use WriteString")]
 		public virtual void  WriteChars(char[] s, int start, int length)

Modified: incubator/lucene.net/trunk/src/core/Store/Lock.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/Lock.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/Lock.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/Lock.cs Sun Nov  6 05:24:26 2011
@@ -21,13 +21,13 @@ namespace Lucene.Net.Store
 {
 	
 	/// <summary>An interprocess mutex lock.
-	/// <p/>Typical use might look like:<pre>
+    /// <p/>Typical use might look like:<code>
 	/// new Lock.With(directory.makeLock("my.lock")) {
 	/// public Object doBody() {
 	/// <i>... code to execute while locked ...</i>
 	/// }
 	/// }.run();
-	/// </pre>
+    /// </code>
 	/// 
 	/// 
 	/// </summary>
@@ -38,12 +38,12 @@ namespace Lucene.Net.Store
 	public abstract class Lock
 	{
 		
-		/// <summary>How long {@link #Obtain(long)} waits, in milliseconds,
+		/// <summary>How long <see cref="Obtain(long)" /> waits, in milliseconds,
 		/// in between attempts to acquire the lock. 
 		/// </summary>
 		public static long LOCK_POLL_INTERVAL = 1000;
 		
-		/// <summary>Pass this value to {@link #Obtain(long)} to try
+		/// <summary>Pass this value to <see cref="Obtain(long)" /> to try
 		/// forever to obtain the lock. 
 		/// </summary>
 		public const long LOCK_OBTAIN_WAIT_FOREVER = - 1;
@@ -62,13 +62,13 @@ namespace Lucene.Net.Store
 		protected internal System.Exception failureReason;
 		
 		/// <summary>Attempts to obtain an exclusive lock within amount of
-		/// time given. Polls once per {@link #LOCK_POLL_INTERVAL}
+		/// time given. Polls once per <see cref="LOCK_POLL_INTERVAL" />
 		/// (currently 1000) milliseconds until lockWaitTimeout is
 		/// passed.
 		/// </summary>
 		/// <param name="lockWaitTimeout">length of time to wait in
-		/// milliseconds or {@link
-		/// #LOCK_OBTAIN_WAIT_FOREVER} to retry forever
+		/// milliseconds or <see cref="LOCK_OBTAIN_WAIT_FOREVER" />
+		/// to retry forever
 		/// </param>
 		/// <returns> true if lock was obtained
 		/// </returns>
@@ -126,7 +126,7 @@ namespace Lucene.Net.Store
 		public abstract void  Release();
 		
 		/// <summary>Returns true if the resource is currently locked.  Note that one must
-		/// still call {@link #Obtain()} before using the resource. 
+		/// still call <see cref="Obtain()" /> before using the resource. 
 		/// </summary>
 		public abstract bool IsLocked();
 		
@@ -148,15 +148,15 @@ namespace Lucene.Net.Store
 			/// <summary>Code to execute with exclusive access. </summary>
 			protected internal abstract System.Object DoBody();
 			
-			/// <summary>Calls {@link #doBody} while <i>lock</i> is obtained.  Blocks if lock
+			/// <summary>Calls <see cref="DoBody" /> while <i>lock</i> is obtained.  Blocks if lock
 			/// cannot be obtained immediately.  Retries to obtain lock once per second
 			/// until it is obtained, or until it has tried ten times. Lock is released when
-			/// {@link #doBody} exits.
+			/// <see cref="DoBody" /> exits.
 			/// </summary>
 			/// <throws>  LockObtainFailedException if lock could not </throws>
 			/// <summary> be obtained
 			/// </summary>
-			/// <throws>  IOException if {@link Lock#obtain} throws IOException </throws>
+			/// <throws>  IOException if <see cref="Lock.Obtain(long)" /> throws IOException </throws>
 			public virtual System.Object run()
 			{
 				bool locked = false;

Modified: incubator/lucene.net/trunk/src/core/Store/LockFactory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/LockFactory.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/LockFactory.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/LockFactory.cs Sun Nov  6 05:24:26 2011
@@ -20,13 +20,13 @@ using System;
 namespace Lucene.Net.Store
 {
 	
-	/// <summary> <p/>Base class for Locking implementation.  {@link Directory} uses
+	/// <summary> <p/>Base class for Locking implementation.  <see cref="Directory" /> uses
 	/// instances of this class to implement locking.<p/>
 	/// 
 	/// <p/>Note that there are some useful tools to verify that
-	/// your LockFactory is working correctly: {@link
-	/// VerifyingLockFactory}, {@link LockStressTest}, {@link
-	/// LockVerifyServer}.<p/>
+	/// your LockFactory is working correctly: <see cref="VerifyingLockFactory" />
+	///, <see cref="LockStressTest" />, <see cref="LockVerifyServer" />
+	///.<p/>
 	/// 
 	/// </summary>
 	/// <seealso cref="LockVerifyServer">

Modified: incubator/lucene.net/trunk/src/core/Store/LockObtainFailedException.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/LockObtainFailedException.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/LockObtainFailedException.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/LockObtainFailedException.cs Sun Nov  6 05:24:26 2011
@@ -20,12 +20,12 @@ using System;
 namespace Lucene.Net.Store
 {
 	
-	/// <summary> This exception is thrown when the <code>write.lock</code>
+	/// <summary> This exception is thrown when the <c>write.lock</c>
 	/// could not be acquired.  This
 	/// happens when a writer tries to open an index
 	/// that another writer already has open.
 	/// </summary>
-	/// <seealso cref="Lock.obtain(long)">
+	/// <seealso cref="Lock.Obtain(long)">
 	/// </seealso>
 	[Serializable]
 	public class LockObtainFailedException:System.IO.IOException

Modified: incubator/lucene.net/trunk/src/core/Store/LockReleaseFailedException.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/LockReleaseFailedException.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/LockReleaseFailedException.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/LockReleaseFailedException.cs Sun Nov  6 05:24:26 2011
@@ -20,10 +20,10 @@ using System;
 namespace Lucene.Net.Store
 {
 	
-	/// <summary> This exception is thrown when the <code>write.lock</code>
+	/// <summary> This exception is thrown when the <c>write.lock</c>
 	/// could not be released.
 	/// </summary>
-	/// <seealso cref="Lock.release()">
+	/// <seealso cref="Lock.Release()">
 	/// </seealso>
 	[Serializable]
 	public class LockReleaseFailedException:System.IO.IOException

Modified: incubator/lucene.net/trunk/src/core/Store/LockVerifyServer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/LockVerifyServer.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/LockVerifyServer.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/LockVerifyServer.cs Sun Nov  6 05:24:26 2011
@@ -21,7 +21,7 @@ namespace Lucene.Net.Store
 {
 	
 	/// <summary> Simple standalone server that must be running when you
-	/// use {@link VerifyingLockFactory}.  This server simply
+	/// use <see cref="VerifyingLockFactory" />.  This server simply
 	/// verifies at most one process holds the lock at a time.
 	/// Run without any args to see usage.
 	/// 

Modified: incubator/lucene.net/trunk/src/core/Store/MMapDirectory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/MMapDirectory.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/MMapDirectory.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/MMapDirectory.cs Sun Nov  6 05:24:26 2011
@@ -22,9 +22,9 @@ using Constants = Lucene.Net.Util.Consta
 namespace Lucene.Net.Store
 {
 	
-	/// <summary>File-based {@link Directory} implementation that uses
-	/// mmap for reading, and {@link
-	/// SimpleFSDirectory.SimpleFSIndexOutput} for writing.
+	/// <summary>File-based <see cref="Directory" /> implementation that uses
+	/// mmap for reading, and <see cref="SimpleFSDirectory.SimpleFSIndexOutput" />
+	/// for writing.
 	/// 
 	/// <p/><b>NOTE</b>: memory mapping uses up a portion of the
 	/// virtual memory address space in your process equal to the
@@ -32,13 +32,13 @@ namespace Lucene.Net.Store
 	/// be sure your have plenty of virtual address space, e.g. by
 	/// using a 64 bit JRE, or a 32 bit JRE with indexes that are
 	/// guaranteed to fit within the address space.
-	/// On 32 bit platforms also consult {@link #setMaxChunkSize}
+	/// On 32 bit platforms also consult <see cref="SetMaxChunkSize" />
 	/// if you have problems with mmap failing because of fragmented
 	/// address space. If you get an OutOfMemoryException, it is recommened
 	/// to reduce the chunk size, until it works.
 	/// 
 	/// <p/>Due to <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4724038">
-	/// this bug</a> in Sun's JRE, MMapDirectory's {@link IndexInput#close}
+	/// this bug</a> in Sun's JRE, MMapDirectory's <see cref="IndexInput.Close" />
 	/// is unable to close the underlying OS file handle.  Only when GC
 	/// finally collects the underlying objects, which could be quite
 	/// some time later, will the file handle be closed.
@@ -53,10 +53,10 @@ namespace Lucene.Net.Store
 	/// an important limitation to be aware of.
 	/// 
 	/// <p/>This class supplies the workaround mentioned in the bug report
-	/// (disabled by default, see {@link #setUseUnmap}), which may fail on
+	/// (disabled by default, see <see cref="SetUseUnmap" />), which may fail on
 	/// non-Sun JVMs. It forcefully unmaps the buffer on close by using
 	/// an undocumented internal cleanup functionality.
-	/// {@link #UNMAP_SUPPORTED} is <code>true</code>, if the workaround
+	/// <see cref="UNMAP_SUPPORTED" /> is <c>true</c>, if the workaround
 	/// can be enabled (with no guarantees).
 	/// </summary>
 	public class MMapDirectory:FSDirectory
@@ -169,20 +169,20 @@ namespace Lucene.Net.Store
 		private bool useUnmapHack = false;
 		private int maxBBuf;
 		
-		/// <summary> <code>true</code>, if this platform supports unmapping mmaped files.</summary>
+		/// <summary> <c>true</c>, if this platform supports unmapping mmaped files.</summary>
 		public static bool UNMAP_SUPPORTED;
 		
 		/// <summary> This method enables the workaround for unmapping the buffers
-		/// from address space after closing {@link IndexInput}, that is
+		/// from address space after closing <see cref="IndexInput" />, that is
 		/// mentioned in the bug report. This hack may fail on non-Sun JVMs.
 		/// It forcefully unmaps the buffer on close by using
 		/// an undocumented internal cleanup functionality.
 		/// <p/><b>NOTE:</b> Enabling this is completely unsupported
-		/// by Java and may lead to JVM crashs if <code>IndexInput</code>
+		/// by Java and may lead to JVM crashs if <c>IndexInput</c>
 		/// is closed while another thread is still accessing it (SIGSEGV).
 		/// </summary>
-		/// <throws>  IllegalArgumentException if {@link #UNMAP_SUPPORTED} </throws>
-		/// <summary> is <code>false</code> and the workaround cannot be enabled.
+		/// <throws>  IllegalArgumentException if <see cref="UNMAP_SUPPORTED" /> </throws>
+		/// <summary> is <c>false</c> and the workaround cannot be enabled.
 		/// </summary>
 		public virtual void  SetUseUnmap(bool useUnmapHack)
 		{
@@ -191,8 +191,8 @@ namespace Lucene.Net.Store
 			this.useUnmapHack = useUnmapHack;
 		}
 		
-		/// <summary> Returns <code>true</code>, if the unmap workaround is enabled.</summary>
-		/// <seealso cref="setUseUnmap">
+		/// <summary> Returns <c>true</c>, if the unmap workaround is enabled.</summary>
+		/// <seealso cref="SetUseUnmap">
 		/// </seealso>
 		public virtual bool GetUseUnmap()
 		{
@@ -221,14 +221,14 @@ namespace Lucene.Net.Store
 			}
 		}
 		
-		/// <summary> Sets the maximum chunk size (default is {@link Integer#MAX_VALUE} for
+		/// <summary> Sets the maximum chunk size (default is <see cref="int.MaxValue" /> for
 		/// 64 bit JVMs and 256 MiBytes for 32 bit JVMs) used for memory mapping.
 		/// Especially on 32 bit platform, the address space can be very fragmented,
 		/// so large index files cannot be mapped.
 		/// Using a lower chunk size makes the directory implementation a little
 		/// bit slower (as the correct chunk must be resolved on each seek)
 		/// but the chance is higher that mmap does not fail. On 64 bit
-		/// Java platforms, this parameter should always be {@link Integer#MAX_VALUE},
+		/// Java platforms, this parameter should always be <see cref="int.MaxValue" />,
 		/// as the adress space is big enough.
 		/// </summary>
 		public virtual void  SetMaxChunkSize(int maxBBuf)
@@ -239,7 +239,7 @@ namespace Lucene.Net.Store
 		}
 		
 		/// <summary> Returns the current mmap chunk size.</summary>
-		/// <seealso cref="setMaxChunkSize">
+		/// <seealso cref="SetMaxChunkSize">
 		/// </seealso>
 		public virtual int GetMaxChunkSize()
 		{

Modified: incubator/lucene.net/trunk/src/core/Store/NIOFSDirectory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/NIOFSDirectory.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/NIOFSDirectory.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/NIOFSDirectory.cs Sun Nov  6 05:24:26 2011
@@ -49,13 +49,13 @@ namespace Lucene.Net.Store
 //namespace Lucene.Net.Store
 //{
 	
-//    /// <summary> An {@link FSDirectory} implementation that uses
+//    /// <summary> An <see cref="FSDirectory" /> implementation that uses
 //    /// java.nio's FileChannel's positional read, which allows
 //    /// multiple threads to read from the same file without
 //    /// synchronizing.
 //    /// 
 //    /// <p/>This class only uses FileChannel when reading; writing
-//    /// is achieved with {@link SimpleFSDirectory.SimpleFSIndexOutput}.
+//    /// is achieved with <see cref="SimpleFSDirectory.SimpleFSIndexOutput" />.
 //    /// 
 //    /// <p/><b>NOTE</b>: NIOFSDirectory is not recommended on Windows because of a bug
 //    /// in how FileChannel.read is implemented in Sun's JRE.

Modified: incubator/lucene.net/trunk/src/core/Store/NativeFSLockFactory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/NativeFSLockFactory.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/NativeFSLockFactory.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/NativeFSLockFactory.cs Sun Nov  6 05:24:26 2011
@@ -20,31 +20,31 @@ using System;
 namespace Lucene.Net.Store
 {
 	
-	/// <summary> <p/>Implements {@link LockFactory} using native OS file
+	/// <summary> <p/>Implements <see cref="LockFactory" /> using native OS file
 	/// locks.  Note that because this LockFactory relies on
 	/// java.nio.* APIs for locking, any problems with those APIs
 	/// will cause locking to fail.  Specifically, on certain NFS
 	/// environments the java.nio.* locks will fail (the lock can
-	/// incorrectly be double acquired) whereas {@link
-	/// SimpleFSLockFactory} worked perfectly in those same
+	/// incorrectly be double acquired) whereas <see cref="SimpleFSLockFactory" />
+	/// worked perfectly in those same
 	/// environments.  For NFS based access to an index, it's
-	/// recommended that you try {@link SimpleFSLockFactory}
+	/// recommended that you try <see cref="SimpleFSLockFactory" />
 	/// first and work around the one limitation that a lock file
 	/// could be left when the JVM exits abnormally.<p/>
 	/// 
-	/// <p/>The primary benefit of {@link NativeFSLockFactory} is
+	/// <p/>The primary benefit of <see cref="NativeFSLockFactory" /> is
 	/// that lock files will be properly removed (by the OS) if
 	/// the JVM has an abnormal exit.<p/>
 	/// 
-	/// <p/>Note that, unlike {@link SimpleFSLockFactory}, the existence of
+	/// <p/>Note that, unlike <see cref="SimpleFSLockFactory" />, the existence of
 	/// leftover lock files in the filesystem on exiting the JVM
 	/// is fine because the OS will free the locks held against
 	/// these files even though the files still remain.<p/>
 	/// 
 	/// <p/>If you suspect that this or any other LockFactory is
 	/// not working properly in your environment, you can easily
-	/// test it by using {@link VerifyingLockFactory}, {@link
-	/// LockVerifyServer} and {@link LockStressTest}.<p/>
+	/// test it by using <see cref="VerifyingLockFactory" />, <see cref="LockVerifyServer" />
+	/// and <see cref="LockStressTest" />.<p/>
 	/// 
 	/// </summary>
 	/// <seealso cref="LockFactory">
@@ -53,7 +53,7 @@ namespace Lucene.Net.Store
 	public class NativeFSLockFactory:FSLockFactory
 	{
 		/// <summary> Create a NativeFSLockFactory instance, with null (unset)
-		/// lock directory. When you pass this factory to a {@link FSDirectory}
+		/// lock directory. When you pass this factory to a <see cref="FSDirectory" />
 		/// subclass, the lock directory is automatically set to the
 		/// directory itsself. Be sure to create one instance for each directory
 		/// your create!

Modified: incubator/lucene.net/trunk/src/core/Store/NoLockFactory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/NoLockFactory.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/NoLockFactory.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/NoLockFactory.cs Sun Nov  6 05:24:26 2011
@@ -20,10 +20,10 @@ using System;
 namespace Lucene.Net.Store
 {
 	
-	/// <summary> Use this {@link LockFactory} to disable locking entirely.
-	/// This LockFactory is used when you call {@link FSDirectory#setDisableLocks}.
-	/// Only one instance of this lock is created.  You should call {@link
-	/// #GetNoLockFactory()} to get the instance.
+	/// <summary> Use this <see cref="LockFactory" /> to disable locking entirely.
+	/// This LockFactory is used when you call <see cref="FSDirectory.SetDisableLocks" />.
+	/// Only one instance of this lock is created.  You should call <see cref="GetNoLockFactory()" />
+	/// to get the instance.
 	/// 
 	/// </summary>
 	/// <seealso cref="LockFactory">

Modified: incubator/lucene.net/trunk/src/core/Store/RAMDirectory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/RAMDirectory.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/RAMDirectory.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/RAMDirectory.cs Sun Nov  6 05:24:26 2011
@@ -19,10 +19,10 @@ using System;
 
 namespace Lucene.Net.Store
 {
-	
-	/// <summary> A memory-resident {@link Directory} implementation.  Locking
-	/// implementation is by default the {@link SingleInstanceLockFactory}
-	/// but can be changed with {@link #setLockFactory}.
+
+    /// <summary> A memory-resident <see cref="Directory"/> implementation.  Locking
+    /// implementation is by default the <see cref="SingleInstanceLockFactory"/>
+    /// but can be changed with <see cref="Directory.SetLockFactory"/>.
 	/// 
 	/// </summary>
 	/// <version>  $Id: RAMDirectory.java 781333 2009-06-03 10:38:57Z mikemccand $
@@ -39,29 +39,29 @@ namespace Lucene.Net.Store
 		// *****
 		// Lock acquisition sequence:  RAMDirectory, then RAMFile
 		// *****
-		
-		/// <summary>Constructs an empty {@link Directory}. </summary>
+
+        /// <summary>Constructs an empty <see cref="Directory"/>. </summary>
 		public RAMDirectory()
 		{
 			SetLockFactory(new SingleInstanceLockFactory());
 		}
 		
-		/// <summary> Creates a new <code>RAMDirectory</code> instance from a different
-		/// <code>Directory</code> implementation.  This can be used to load
+		/// <summary> Creates a new <c>RAMDirectory</c> instance from a different
+		/// <c>Directory</c> implementation.  This can be used to load
 		/// a disk-based index into memory.
 		/// <p/>
 		/// This should be used only with indices that can fit into memory.
 		/// <p/>
-		/// Note that the resulting <code>RAMDirectory</code> instance is fully
-		/// independent from the original <code>Directory</code> (it is a
+		/// Note that the resulting <c>RAMDirectory</c> instance is fully
+		/// independent from the original <c>Directory</c> (it is a
 		/// complete copy).  Any subsequent changes to the
-		/// original <code>Directory</code> will not be visible in the
-		/// <code>RAMDirectory</code> instance.
+		/// original <c>Directory</c> will not be visible in the
+		/// <c>RAMDirectory</c> instance.
 		/// 
 		/// </summary>
-		/// <param name="dir">a <code>Directory</code> value
+		/// <param name="dir">a <c>Directory</c> value
 		/// </param>
-		/// <exception cref="IOException">if an error occurs
+		/// <exception cref="System.IO.IOException">if an error occurs
 		/// </exception>
 		public RAMDirectory(Directory dir):this(dir, false)
 		{
@@ -71,31 +71,31 @@ namespace Lucene.Net.Store
 		{
 			Directory.Copy(dir, this, closeDir);
 		}
-		
-		/// <summary> Creates a new <code>RAMDirectory</code> instance from the {@link FSDirectory}.
+
+        /// <summary> Creates a new <c>RAMDirectory</c> instance from the <see cref="FSDirectory"/>.
 		/// 
 		/// </summary>
-		/// <param name="dir">a <code>File</code> specifying the index directory
+		/// <param name="dir">a <c>File</c> specifying the index directory
 		/// 
 		/// </param>
 		/// <seealso cref="RAMDirectory(Directory)">
 		/// </seealso>
-		/// <deprecated> Use {@link #RAMDirectory(Directory)} instead
+        /// <deprecated> Use <see cref="RAMDirectory(Directory)"/> instead
 		/// </deprecated>
         [Obsolete("Use RAMDirectory(Directory) instead")]
 		public RAMDirectory(System.IO.FileInfo dir):this(FSDirectory.GetDirectory(dir), true)
 		{
 		}
-		
-		/// <summary> Creates a new <code>RAMDirectory</code> instance from the {@link FSDirectory}.
+
+        /// <summary> Creates a new <c>RAMDirectory</c> instance from the <see cref="FSDirectory"/>.
 		/// 
 		/// </summary>
-		/// <param name="dir">a <code>String</code> specifying the full index directory path
+		/// <param name="dir">a <c>String</c> specifying the full index directory path
 		/// 
 		/// </param>
 		/// <seealso cref="RAMDirectory(Directory)">
 		/// </seealso>
-		/// <deprecated> Use {@link #RAMDirectory(Directory)} instead
+        /// <deprecated> Use <see cref="RAMDirectory(Directory)"/> instead
 		/// </deprecated>
         [Obsolete("Use RAMDirectory(Directory) instead")]
 		public RAMDirectory(System.String dir):this(FSDirectory.GetDirectory(dir), true)

Modified: incubator/lucene.net/trunk/src/core/Store/RAMInputStream.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/RAMInputStream.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/RAMInputStream.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/RAMInputStream.cs Sun Nov  6 05:24:26 2011
@@ -20,7 +20,7 @@ using System;
 namespace Lucene.Net.Store
 {
 	
-	/// <summary> A memory-resident {@link IndexInput} implementation.
+	/// <summary> A memory-resident <see cref="IndexInput" /> implementation.
 	/// 
 	/// </summary>
 	/// <version>  $Id: RAMInputStream.java 632120 2008-02-28 21:13:59Z mikemccand $

Modified: incubator/lucene.net/trunk/src/core/Store/RAMOutputStream.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/RAMOutputStream.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/RAMOutputStream.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/RAMOutputStream.cs Sun Nov  6 05:24:26 2011
@@ -20,7 +20,7 @@ using System;
 namespace Lucene.Net.Store
 {
 	
-	/// <summary> A memory-resident {@link IndexOutput} implementation.
+	/// <summary> A memory-resident <see cref="IndexOutput" /> implementation.
 	/// 
 	/// </summary>
 	/// <version>  $Id: RAMOutputStream.java 691694 2008-09-03 17:34:29Z mikemccand $

Modified: incubator/lucene.net/trunk/src/core/Store/SimpleFSDirectory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/SimpleFSDirectory.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/SimpleFSDirectory.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/SimpleFSDirectory.cs Sun Nov  6 05:24:26 2011
@@ -20,12 +20,12 @@ using System;
 namespace Lucene.Net.Store
 {
 	
-	/// <summary>A straightforward implementation of {@link FSDirectory}
+	/// <summary>A straightforward implementation of <see cref="FSDirectory" />
 	/// using java.io.RandomAccessFile.  However, this class has
 	/// poor concurrent performance (multiple threads will
 	/// bottleneck) as it synchronizes when multiple threads
 	/// read from the same file.  It's usually better to use
-	/// {@link NIOFSDirectory} or {@link MMapDirectory} instead. 
+	/// <see cref="NIOFSDirectory" /> or <see cref="MMapDirectory" /> instead. 
 	/// </summary>
 	public class SimpleFSDirectory:FSDirectory
 	{

Modified: incubator/lucene.net/trunk/src/core/Store/SimpleFSLockFactory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/SimpleFSLockFactory.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/SimpleFSLockFactory.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/SimpleFSLockFactory.cs Sun Nov  6 05:24:26 2011
@@ -20,31 +20,31 @@ using System;
 namespace Lucene.Net.Store
 {
 	
-	/// <summary> <p/>Implements {@link LockFactory} using {@link
-	/// File#createNewFile()}.<p/>
+	/// <summary> <p/>Implements <see cref="LockFactory" /> using <see cref="System.IO.FileInfo.Create()" />
+	///.<p/>
 	/// 
 	/// <p/><b>NOTE:</b> the <a target="_top"
 	/// href="http://java.sun.com/j2se/1.4.2/docs/api/java/io/File.html#createNewFile()">javadocs
-	/// for <code>File.createNewFile</code></a> contain a vague
+	/// for <c>File.createNewFile</c></a> contain a vague
 	/// yet spooky warning about not using the API for file
 	/// locking.  This warning was added due to <a target="_top"
 	/// href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4676183">this
 	/// bug</a>, and in fact the only known problem with using
 	/// this API for locking is that the Lucene write lock may
 	/// not be released when the JVM exits abnormally.<p/>
-	/// <p/>When this happens, a {@link LockObtainFailedException}
+	/// <p/>When this happens, a <see cref="LockObtainFailedException" />
 	/// is hit when trying to create a writer, in which case you
 	/// need to explicitly clear the lock file first.  You can
-	/// either manually remove the file, or use the {@link
-	/// org.apache.lucene.index.IndexReader#unlock(Directory)}
+	/// either manually remove the file, or use the <see cref="Lucene.Net.Index.IndexReader.Unlock(Directory)" />
+	///
 	/// API.  But, first be certain that no writer is in fact
 	/// writing to the index otherwise you can easily corrupt
 	/// your index.<p/>
 	/// 
 	/// <p/>If you suspect that this or any other LockFactory is
 	/// not working properly in your environment, you can easily
-	/// test it by using {@link VerifyingLockFactory}, {@link
-	/// LockVerifyServer} and {@link LockStressTest}.<p/>
+	/// test it by using <see cref="VerifyingLockFactory" />, <see cref="LockVerifyServer" />
+	/// and <see cref="LockStressTest" />.<p/>
 	/// 
 	/// </summary>
 	/// <seealso cref="LockFactory">
@@ -54,7 +54,7 @@ namespace Lucene.Net.Store
 	{
 		
 		/// <summary> Create a SimpleFSLockFactory instance, with null (unset)
-		/// lock directory. When you pass this factory to a {@link FSDirectory}
+		/// lock directory. When you pass this factory to a <see cref="FSDirectory" />
 		/// subclass, the lock directory is automatically set to the
 		/// directory itsself. Be sure to create one instance for each directory
 		/// your create!

Modified: incubator/lucene.net/trunk/src/core/Store/SingleInstanceLockFactory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/SingleInstanceLockFactory.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/SingleInstanceLockFactory.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/SingleInstanceLockFactory.cs Sun Nov  6 05:24:26 2011
@@ -20,9 +20,9 @@ using System;
 namespace Lucene.Net.Store
 {
 	
-	/// <summary> Implements {@link LockFactory} for a single in-process instance,
+	/// <summary> Implements <see cref="LockFactory" /> for a single in-process instance,
 	/// meaning all locking will take place through this one instance.
-	/// Only use this {@link LockFactory} when you are certain all
+	/// Only use this <see cref="LockFactory" /> when you are certain all
 	/// IndexReaders and IndexWriters for a given index are running
 	/// against a single shared in-process Directory instance.  This is
 	/// currently the default locking for RAMDirectory.

Modified: incubator/lucene.net/trunk/src/core/Store/VerifyingLockFactory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Store/VerifyingLockFactory.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Store/VerifyingLockFactory.cs (original)
+++ incubator/lucene.net/trunk/src/core/Store/VerifyingLockFactory.cs Sun Nov  6 05:24:26 2011
@@ -20,13 +20,13 @@ using System;
 namespace Lucene.Net.Store
 {
 	
-	/// <summary> A {@link LockFactory} that wraps another {@link
-	/// LockFactory} and verifies that each lock obtain/release
+	/// <summary> A <see cref="LockFactory" /> that wraps another <see cref="LockFactory" />
+	/// and verifies that each lock obtain/release
 	/// is "correct" (never results in two processes holding the
 	/// lock at the same time).  It does this by contacting an
-	/// external server ({@link LockVerifyServer}) to assert that
+	/// external server (<see cref="LockVerifyServer" />) to assert that
 	/// at most one process holds the lock at a time.  To use
-	/// this, you should also run {@link LockVerifyServer} on the
+	/// this, you should also run <see cref="LockVerifyServer" /> on the
 	/// host &amp; port matching what you pass to the constructor.
 	/// 
 	/// </summary>
@@ -132,10 +132,10 @@ namespace Lucene.Net.Store
 		/// </param>
 		/// <param name="lf">the LockFactory that we are testing
 		/// </param>
-		/// <param name="host">host or IP where {@link LockVerifyServer}
+		/// <param name="host">host or IP where <see cref="LockVerifyServer" />
 		/// is running
 		/// </param>
-		/// <param name="port">the port {@link LockVerifyServer} is
+		/// <param name="port">the port <see cref="LockVerifyServer" /> is
 		/// listening on
 		/// </param>
 		public VerifyingLockFactory(sbyte id, LockFactory lf, System.String host, int port)

Modified: incubator/lucene.net/trunk/src/core/SupportClass.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/SupportClass.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/SupportClass.cs (original)
+++ incubator/lucene.net/trunk/src/core/SupportClass.cs Sun Nov  6 05:24:26 2011
@@ -968,8 +968,8 @@ public class SupportClass
         /// <summary>
         /// 
         /// </summary>
-        /// <param name="Key"></param>
-        /// <param name="Value"></param>
+        /// <param name="key"></param>
+        /// <param name="defValue"></param>
         public static void Set(System.String key, System.String defValue)
         {
             settings[key] = defValue;
@@ -978,8 +978,8 @@ public class SupportClass
         /// <summary>
         /// 
         /// </summary>
-        /// <param name="Key"></param>
-        /// <param name="Value"></param>
+        /// <param name="key"></param>
+        /// <param name="defValue"></param>
         public static void Set(System.String key, bool defValue)
         {
             settings[key] = defValue;
@@ -1742,7 +1742,7 @@ public class SupportClass
     internal class GeneralKeyedCollection<TKey, TItem> : System.Collections.ObjectModel.KeyedCollection<TKey, TItem>
     {
         /// <summary>Creates a new instance of the
-        /// <see cref="GeneralKeyedCollection"/> class.</summary>
+        /// <see cref="GeneralKeyedCollection{TKey, TItem}"/> class.</summary>
         /// <param name="converter">The <see cref="Converter{TInput, TOutput}"/> which will convert
         /// instances of <typeparamref name="TItem"/> to <typeparamref name="TKey"/>
         /// when the override of <see cref="GetKeyForItem(TItem)"/> is called.</param>
@@ -1808,17 +1808,17 @@ public class SupportClass
         ICloneable
     {
         /// <summary>Initializes a new instance of the 
-        /// <see cref="ComparableList{T}"/> class that is empty and has the 
+        /// <see cref="EquatableList{T}"/> class that is empty and has the 
         /// default initial capacity.</summary>
         public EquatableList() : base() { }
 
-        /// <summary>Initializes a new instance of the <see cref="ComparableList{T}"/>
+        /// <summary>Initializes a new instance of the <see cref="EquatableList{T}"/>
         /// class that contains elements copied from the specified collection and has
         /// sufficient capacity to accommodate the number of elements copied.</summary>
         /// <param name="collection">The collection whose elements are copied to the new list.</param>
         public EquatableList(System.Collections.Generic.IEnumerable<T> collection) : base(collection) { }
 
-        /// <summary>Initializes a new instance of the <see cref="ComparableList{T}"/> 
+        /// <summary>Initializes a new instance of the <see cref="EquatableList{T}"/> 
         /// class that is empty and has the specified initial capacity.</summary>
         /// <param name="capacity">The number of elements that the new list can initially store.</param>
         public EquatableList(int capacity) : base(capacity) { }
@@ -1843,20 +1843,20 @@ public class SupportClass
             }
         }
 
-        /// <summary>Compares the counts of two <see cref="IEnumerable{T}"/>
+        /// <summary>Compares the counts of two <see cref="System.Collections.Generic.IEnumerable{T}"/>
         /// implementations.</summary>
         /// <remarks>This uses a trick in LINQ, sniffing types for implementations
         /// of interfaces that might supply shortcuts when trying to make comparisons.
-        /// In this case, that is the <see cref="ICollection{T}"/> and
+        /// In this case, that is the <see cref="System.Collections.Generic.ICollection{T}"/> and
         /// <see cref="ICollection"/> interfaces, either of which can provide a count
         /// which can be used in determining the equality of sequences (if they don't have
         /// the same count, then they can't be equal).</remarks>
-        /// <param name="x">The <see cref="IEnumerable{T}"/> from the left hand side of the
+        /// <param name="x">The <see cref="System.Collections.Generic.IEnumerable{T}"/> from the left hand side of the
         /// comparison to check the count of.</param>
-        /// <param name="y">The <see cref="IEnumerable{T}"/> from the right hand side of the
+        /// <param name="y">The <see cref="System.Collections.Generic.IEnumerable{T}"/> from the right hand side of the
         /// comparison to check the count of.</param>
         /// <returns>Null if the result is indeterminate.  This occurs when either <paramref name="x"/>
-        /// or <paramref name="y"/> doesn't implement <see cref="ICollection"/> or <see cref="ICollection{T}"/>.
+        /// or <paramref name="y"/> doesn't implement <see cref="ICollection"/> or <see cref="System.Collections.Generic.ICollection{T}"/>.
         /// Otherwise, it will get the count from each and return true if they are equal, false otherwise.</returns>
         private static bool? EnumerableCountsEqual(System.Collections.Generic.IEnumerable<T> x, System.Collections.Generic.IEnumerable<T> y)
         {
@@ -1881,17 +1881,17 @@ public class SupportClass
             return xCount == yCount;
         }
 
-        /// <summary>Compares the contents of a <see cref="IEnumerable{T}"/>
+        /// <summary>Compares the contents of a <see cref="System.Collections.Generic.IEnumerable{T}"/>
         /// implementation to another one to determine equality.</summary>
-        /// <remarks>Thinking of the <see cref="IEnumerable{T}"/> implementation as
+        /// <remarks>Thinking of the <see cref="System.Collections.Generic.IEnumerable{T}"/> implementation as
         /// a string with any number of characters, the algorithm checks
         /// each item in each list.  If any item of the list is not equal (or
         /// one list contains all the elements of another list), then that list
         /// element is compared to the other list element to see which
         /// list is greater.</remarks>
-        /// <param name="x">The <see cref="IEnumerable{T}"/> implementation
+        /// <param name="x">The <see cref="System.Collections.Generic.IEnumerable{T}"/> implementation
         /// that is considered the left hand side.</param>
-        /// <param name="y">The <see cref="IEnumerable{T}"/> implementation
+        /// <param name="y">The <see cref="System.Collections.Generic.IEnumerable{T}"/> implementation
         /// that is considered the right hand side.</param>
         /// <returns>True if the items are equal, false otherwise.</returns>
         private static bool Equals(System.Collections.Generic.IEnumerable<T> x,
@@ -1976,9 +1976,9 @@ public class SupportClass
         }
 
 #region IEquatable<IEnumerable<T>> Members
-        /// <summary>Compares this sequence to another <see cref="IEnumerable{T}"/>
+        /// <summary>Compares this sequence to another <see cref="System.Collections.Generic.IEnumerable{T}"/>
         /// implementation, returning true if they are equal, false otherwise.</summary>
-        /// <param name="other">The other <see cref="IEnumerable{T}"/> implementation
+        /// <param name="other">The other <see cref="System.Collections.Generic.IEnumerable{T}"/> implementation
         /// to compare against.</param>
         /// <returns>True if the sequence in <paramref name="other"/> 
         /// is the same as this one.</returns>
@@ -2011,8 +2011,7 @@ public class SupportClass
         public static int GetHashCode<T>(System.Collections.Generic.IEnumerable<T> source)
         #else
         /// <summary>Gets the hash code for the list.</summary>
-        /// <param name="source">The <see cref="IEnumerable{T}"/>
-        /// <param name="source">The <see cref="IEnumerable<T>"/>
+        /// <param name="source">The <see cref="System.Collections.Generic.IEnumerable{T}"/>
         /// implementation which will have all the contents hashed.</param>
         /// <returns>The hash code value.</returns>
         public static int GetHashCode(System.Collections.Generic.IEnumerable<T> source)

Modified: incubator/lucene.net/trunk/src/core/Util/ArrayUtil.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/ArrayUtil.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/ArrayUtil.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/ArrayUtil.cs Sun Nov  6 05:24:26 2011
@@ -59,21 +59,23 @@ namespace Lucene.Net.Util
 		{
 			return ParseInt(chars, offset, len, 10);
 		}
-		
-		/// <summary> Parses the string argument as if it was an int value and returns the
-		/// result. Throws NumberFormatException if the string does not represent an
-		/// int quantity. The second argument specifies the radix to use when parsing
-		/// the value.
-		/// 
-		/// </summary>
-		/// <param name="chars">a string representation of an int quantity.
-		/// </param>
-		/// <param name="radix">the base to use for conversion.
-		/// </param>
-		/// <returns> int the value represented by the argument
-		/// </returns>
-		/// <throws>  NumberFormatException if the argument could not be parsed as an int quantity. </throws>
-		public static int ParseInt(char[] chars, int offset, int len, int radix)
+
+	    /// <summary> Parses the string argument as if it was an int value and returns the
+	    /// result. Throws NumberFormatException if the string does not represent an
+	    /// int quantity. The second argument specifies the radix to use when parsing
+	    /// the value.
+	    /// 
+	    /// </summary>
+	    /// <param name="chars">a string representation of an int quantity.
+	    /// </param>
+	    /// <param name="offset"></param>
+	    /// <param name="len"></param>
+	    /// <param name="radix">the base to use for conversion.
+	    /// </param>
+	    /// <returns> int the value represented by the argument
+	    /// </returns>
+	    /// <throws>  NumberFormatException if the argument could not be parsed as an int quantity. </throws>
+	    public static int ParseInt(char[] chars, int offset, int len, int radix)
 		{
 			if (chars == null || radix < 2 || radix > 36)
 			{

Modified: incubator/lucene.net/trunk/src/core/Util/AttributeImpl.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/AttributeImpl.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/AttributeImpl.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/AttributeImpl.cs Sun Nov  6 05:24:26 2011
@@ -21,10 +21,10 @@ namespace Lucene.Net.Util
 {
 	
 	/// <summary> Base class for Attributes that can be added to a 
-	/// {@link Lucene.Net.Util.AttributeSource}.
+	/// <see cref="Lucene.Net.Util.AttributeSource" />.
 	/// <p/>
 	/// Attributes are used to add data in a dynamic, yet type-safe way to a source
-	/// of usually streamed objects, e. g. a {@link Lucene.Net.Analysis.TokenStream}.
+	/// of usually streamed objects, e. g. a <see cref="Lucene.Net.Analysis.TokenStream" />.
 	/// </summary>
 	[Serializable]
 	public abstract class AttributeImpl : System.ICloneable, Attribute
@@ -38,11 +38,11 @@ namespace Lucene.Net.Util
 		/// <summary> The default implementation of this method accesses all declared
 		/// fields of this object and prints the values in the following syntax:
 		/// 
-		/// <pre>
+        /// <code>
 		/// public String toString() {
 		/// return "start=" + startOffset + ",end=" + endOffset;
 		/// }
-		/// </pre>
+        /// </code>
 		/// 
 		/// This method may be overridden by subclasses.
 		/// </summary>
@@ -86,24 +86,24 @@ namespace Lucene.Net.Util
 		
 		/// <summary> Subclasses must implement this method and should compute
 		/// a hashCode similar to this:
-		/// <pre>
+		/// <code>
 		/// public int hashCode() {
 		/// int code = startOffset;
 		/// code = code * 31 + endOffset;
 		/// return code;
 		/// }
-		/// </pre> 
+		/// </code> 
 		/// 
-		/// see also {@link #equals(Object)}
+		/// see also <see cref="Equals(Object)" />
 		/// </summary>
 		abstract public override int GetHashCode();
 		
-		/// <summary> All values used for computation of {@link #hashCode()} 
+		/// <summary> All values used for computation of <see cref="GetHashCode()" /> 
 		/// should be checked here for equality.
 		/// 
-		/// see also {@link Object#equals(Object)}
+		/// see also <see cref="Object.Equals(Object)" />
 		/// </summary>
-		abstract public  override bool Equals(System.Object other);
+		abstract public override bool Equals(System.Object other);
 		
 		/// <summary> Copies the values from this Attribute into the passed-in
 		/// target attribute. The target implementation must support all the

Modified: incubator/lucene.net/trunk/src/core/Util/AttributeSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/AttributeSource.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/AttributeSource.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/AttributeSource.cs Sun Nov  6 05:24:26 2011
@@ -22,26 +22,26 @@ using TokenStream = Lucene.Net.Analysis.
 namespace Lucene.Net.Util
 {
 	
-	/// <summary> An AttributeSource contains a list of different {@link AttributeImpl}s,
+	/// <summary> An AttributeSource contains a list of different <see cref="AttributeImpl" />s,
 	/// and methods to add and get them. There can only be a single instance
 	/// of an attribute in the same AttributeSource instance. This is ensured
 	/// by passing in the actual type of the Attribute (Class&lt;Attribute&gt;) to 
-	/// the {@link #AddAttribute(Class)}, which then checks if an instance of
+	/// the <see cref="AddAttribute(Type)" />, which then checks if an instance of
 	/// that type is already present. If yes, it returns the instance, otherwise
 	/// it creates a new instance and returns it.
 	/// </summary>
 	public class AttributeSource
 	{
-		/// <summary> An AttributeFactory creates instances of {@link AttributeImpl}s.</summary>
+		/// <summary> An AttributeFactory creates instances of <see cref="AttributeImpl" />s.</summary>
 		public abstract class AttributeFactory
 		{
-			/// <summary> returns an {@link AttributeImpl} for the supplied {@link Attribute} interface class.
-			/// <p/>Signature for Java 1.5: <code>public AttributeImpl createAttributeInstance(Class%lt;? extends Attribute&gt; attClass)</code>
+			/// <summary> returns an <see cref="AttributeImpl" /> for the supplied <see cref="Attribute" /> interface class.
+			/// <p/>Signature for Java 1.5: <c>public AttributeImpl createAttributeInstance(Class%lt;? extends Attribute&gt; attClass)</c>
 			/// </summary>
 			public abstract AttributeImpl CreateAttributeInstance(System.Type attClass);
 			
-			/// <summary> This is the default factory that creates {@link AttributeImpl}s using the
-			/// class name of the supplied {@link Attribute} interface class by appending <code>Impl</code> to it.
+			/// <summary> This is the default factory that creates <see cref="AttributeImpl" />s using the
+			/// class name of the supplied <see cref="Attribute" /> interface class by appending <c>Impl</c> to it.
 			/// </summary>
 			public static readonly AttributeFactory DEFAULT_ATTRIBUTE_FACTORY = new DefaultAttributeFactory();
 			
@@ -100,7 +100,7 @@ namespace Lucene.Net.Util
 		
 		private AttributeFactory factory;
 		
-		/// <summary> An AttributeSource using the default attribute factory {@link AttributeSource.AttributeFactory#DEFAULT_ATTRIBUTE_FACTORY}.</summary>
+		/// <summary> An AttributeSource using the default attribute factory <see cref="AttributeSource.AttributeFactory.DEFAULT_ATTRIBUTE_FACTORY" />.</summary>
 		public AttributeSource():this(AttributeFactory.DEFAULT_ATTRIBUTE_FACTORY)
 		{
 		}
@@ -117,7 +117,7 @@ namespace Lucene.Net.Util
 			this.factory = input.factory;
 		}
 		
-		/// <summary> An AttributeSource using the supplied {@link AttributeFactory} for creating new {@link Attribute} instances.</summary>
+		/// <summary> An AttributeSource using the supplied <see cref="AttributeFactory" /> for creating new <see cref="Attribute" /> instances.</summary>
 		public AttributeSource(AttributeFactory factory)
 		{
             this.attributes = new SupportClass.GeneralKeyedCollection<Type, SupportClass.AttributeImplItem>(delegate(SupportClass.AttributeImplItem att) { return att.Key; });
@@ -133,7 +133,7 @@ namespace Lucene.Net.Util
 		
 		/// <summary>Returns a new iterator that iterates the attribute classes
 		/// in the same order they were added in.
-		/// Signature for Java 1.5: <code>public Iterator&lt;Class&lt;? extends Attribute&gt;&gt; getAttributeClassesIterator()</code>
+		/// Signature for Java 1.5: <c>public Iterator&lt;Class&lt;? extends Attribute&gt;&gt; getAttributeClassesIterator()</c>
 		///
 		/// Note that this return value is different from Java in that it enumerates over the values
 		/// and not the keys
@@ -147,9 +147,9 @@ namespace Lucene.Net.Util
 		}
 		
 		/// <summary>Returns a new iterator that iterates all unique Attribute implementations.
-		/// This iterator may contain less entries that {@link #getAttributeClassesIterator},
+		/// This iterator may contain less entries that <see cref="GetAttributeClassesIterator" />,
 		/// if one instance implements more than one Attribute interface.
-		/// Signature for Java 1.5: <code>public Iterator&lt;AttributeImpl&gt; getAttributeImplsIterator()</code>
+		/// Signature for Java 1.5: <c>public Iterator&lt;AttributeImpl&gt; getAttributeImplsIterator()</c>
 		/// </summary>
 		public virtual System.Collections.Generic.IEnumerable<AttributeImpl> GetAttributeImplsIterator()
 		{
@@ -242,7 +242,7 @@ namespace Lucene.Net.Util
 		/// This method first checks if an instance of that class is 
 		/// already in this AttributeSource and returns it. Otherwise a
 		/// new instance is created, added to this AttributeSource and returned. 
-		/// Signature for Java 1.5: <code>public &lt;T extends Attribute&gt; T addAttribute(Class&lt;T&gt;)</code>
+		/// Signature for Java 1.5: <c>public &lt;T extends Attribute&gt; T addAttribute(Class&lt;T&gt;)</c>
 		/// </summary>
 		public virtual Attribute AddAttribute(System.Type attClass)
 		{
@@ -274,7 +274,7 @@ namespace Lucene.Net.Util
 		
 		/// <summary> The caller must pass in a Class&lt;? extends Attribute&gt; value. 
 		/// Returns true, iff this AttributeSource contains the passed-in Attribute.
-		/// Signature for Java 1.5: <code>public boolean hasAttribute(Class&lt;? extends Attribute&gt;)</code>
+		/// Signature for Java 1.5: <c>public boolean hasAttribute(Class&lt;? extends Attribute&gt;)</c>
 		/// </summary>
 		public virtual bool HasAttribute(System.Type attClass)
 		{
@@ -283,15 +283,15 @@ namespace Lucene.Net.Util
 		
 		/// <summary> The caller must pass in a Class&lt;? extends Attribute&gt; value. 
 		/// Returns the instance of the passed in Attribute contained in this AttributeSource
-		/// Signature for Java 1.5: <code>public &lt;T extends Attribute&gt; T getAttribute(Class&lt;T&gt;)</code>
+		/// Signature for Java 1.5: <c>public &lt;T extends Attribute&gt; T getAttribute(Class&lt;T&gt;)</c>
 		/// 
 		/// </summary>
 		/// <throws>  IllegalArgumentException if this AttributeSource does not contain the </throws>
-		/// <summary>         Attribute. It is recommended to always use {@link #addAttribute} even in consumers
+		/// <summary>         Attribute. It is recommended to always use <see cref="AddAttribute" /> even in consumers
 		/// of TokenStreams, because you cannot know if a specific TokenStream really uses
-		/// a specific Attribute. {@link #addAttribute} will automatically make the attribute
+		/// a specific Attribute. <see cref="AddAttribute" /> will automatically make the attribute
 		/// available. If you want to only use the attribute, if it is available (to optimize
-		/// consuming), use {@link #hasAttribute}.
+		/// consuming), use <see cref="HasAttribute" />.
 		/// </summary>
 		public virtual Attribute GetAttribute(System.Type attClass)
 		{
@@ -306,9 +306,9 @@ namespace Lucene.Net.Util
 		}
 		
 		/// <summary> This class holds the state of an AttributeSource.</summary>
-		/// <seealso cref="captureState">
+		/// <seealso cref="CaptureState">
 		/// </seealso>
-		/// <seealso cref="restoreState">
+		/// <seealso cref="RestoreState">
 		/// </seealso>
 		public sealed class State : System.ICloneable
 		{
@@ -347,7 +347,7 @@ namespace Lucene.Net.Util
 		}
 		
 		/// <summary> Resets all Attributes in this AttributeSource by calling
-		/// {@link AttributeImpl#Clear()} on each Attribute implementation.
+		/// <see cref="AttributeImpl.Clear()" /> on each Attribute implementation.
 		/// </summary>
 		public virtual void  ClearAttributes()
 		{
@@ -365,7 +365,7 @@ namespace Lucene.Net.Util
 		}
 		
 		/// <summary> Captures the state of all Attributes. The return value can be passed to
-		/// {@link #restoreState} to restore the state of this or another AttributeSource.
+		/// <see cref="RestoreState" /> to restore the state of this or another AttributeSource.
 		/// </summary>
 		public virtual State CaptureState()
 		{
@@ -393,7 +393,7 @@ namespace Lucene.Net.Util
 		/// the targetStream contains an OffsetAttribute, but this state doesn't, then
 		/// the value of the OffsetAttribute remains unchanged. It might be desirable to
 		/// reset its value to the default, in which case the caller should first
-		/// call {@link TokenStream#ClearAttributes()} on the targetStream.   
+        /// call <see cref="AttributeSource.ClearAttributes()" /> on the targetStream.   
 		/// </summary>
 		public virtual void  RestoreState(State state)
 		{
@@ -506,9 +506,9 @@ namespace Lucene.Net.Util
 			return sb.ToString();
 		}
 		
-		/// <summary> Performs a clone of all {@link AttributeImpl} instances returned in a new
+		/// <summary> Performs a clone of all <see cref="AttributeImpl" /> instances returned in a new
 		/// AttributeSource instance. This method can be used to e.g. create another TokenStream
-		/// with exactly the same attributes (using {@link #AttributeSource(AttributeSource)})
+		/// with exactly the same attributes (using <see cref="AttributeSource(AttributeSource)" />)
 		/// </summary>
 		public virtual AttributeSource CloneAttributes()
 		{

Modified: incubator/lucene.net/trunk/src/core/Util/AverageGuessMemoryModel.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/AverageGuessMemoryModel.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/AverageGuessMemoryModel.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/AverageGuessMemoryModel.cs Sun Nov  6 05:24:26 2011
@@ -87,7 +87,7 @@ namespace Lucene.Net.Util
 		/*
 		* (non-Javadoc)
 		* 
-		* @see Lucene.Net.Util.MemoryModel#getArraySize()
+		* <see cref="Lucene.Net.Util.MemoryModel.getArraySize()"/>
 		*/
 		public override int GetArraySize()
 		{
@@ -97,7 +97,7 @@ namespace Lucene.Net.Util
 		/*
 		* (non-Javadoc)
 		* 
-		* @see Lucene.Net.Util.MemoryModel#getClassSize()
+		* <see cref="Lucene.Net.Util.MemoryModel.getClassSize()"/>
 		*/
 		public override int GetClassSize()
 		{
@@ -105,7 +105,7 @@ namespace Lucene.Net.Util
 		}
 		
 		/* (non-Javadoc)
-		* @see Lucene.Net.Util.MemoryModel#getPrimitiveSize(java.lang.Class)
+		* <see cref="Lucene.Net.Util.MemoryModel.getPrimitiveSize(java.lang.Class)"/>
 		*/
 		public override int GetPrimitiveSize(System.Type clazz)
 		{
@@ -113,7 +113,7 @@ namespace Lucene.Net.Util
 		}
 		
 		/* (non-Javadoc)
-		* @see Lucene.Net.Util.MemoryModel#getReferenceSize()
+		* <see cref="Lucene.Net.Util.MemoryModel.getReferenceSize()"/>
 		*/
 		public override int GetReferenceSize()
 		{

Modified: incubator/lucene.net/trunk/src/core/Util/BitVector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/BitVector.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/BitVector.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/BitVector.cs Sun Nov  6 05:24:26 2011
@@ -26,12 +26,12 @@ namespace Lucene.Net.Util
 	
 	/// <summary>Optimized implementation of a vector of bits.  This is more-or-less like
 	/// java.util.BitSet, but also includes the following:
-	/// <ul>
-	/// <li>a count() method, which efficiently computes the number of one bits;</li>
-	/// <li>optimized read from and write to disk;</li>
-	/// <li>inlinable get() method;</li>
-	/// <li>store and load, as bit set or d-gaps, depending on sparseness;</li> 
-	/// </ul>
+	/// <list type="bullet">
+	/// <item>a count() method, which efficiently computes the number of one bits;</item>
+	/// <item>optimized read from and write to disk;</item>
+	/// <item>inlinable get() method;</item>
+	/// <item>store and load, as bit set or d-gaps, depending on sparseness;</item> 
+	/// </list>
 	/// </summary>
 	/// <version>  $Id: BitVector.java 765649 2009-04-16 14:29:26Z mikemccand $
 	/// </version>
@@ -42,7 +42,7 @@ namespace Lucene.Net.Util
 		private int size;
 		private int count;
 		
-		/// <summary>Constructs a vector capable of holding <code>n</code> bits. </summary>
+		/// <summary>Constructs a vector capable of holding <c>n</c> bits. </summary>
 		public BitVector(int n)
 		{
 			size = n;
@@ -66,7 +66,7 @@ namespace Lucene.Net.Util
             return clone;
 		}
 		
-		/// <summary>Sets the value of <code>bit</code> to one. </summary>
+		/// <summary>Sets the value of <c>bit</c> to one. </summary>
 		public void  Set(int bit)
 		{
 			if (bit >= size)
@@ -77,7 +77,7 @@ namespace Lucene.Net.Util
 			count = - 1;
 		}
 		
-		/// <summary>Sets the value of <code>bit</code> to true, and
+		/// <summary>Sets the value of <c>bit</c> to true, and
 		/// returns true if bit was already set 
 		/// </summary>
 		public bool GetAndSet(int bit)
@@ -100,7 +100,7 @@ namespace Lucene.Net.Util
 			}
 		}
 		
-		/// <summary>Sets the value of <code>bit</code> to zero. </summary>
+		/// <summary>Sets the value of <c>bit</c> to zero. </summary>
 		public void  Clear(int bit)
 		{
 			if (bit >= size)
@@ -111,8 +111,8 @@ namespace Lucene.Net.Util
 			count = - 1;
 		}
 		
-		/// <summary>Returns <code>true</code> if <code>bit</code> is one and
-		/// <code>false</code> if it is zero. 
+		/// <summary>Returns <c>true</c> if <c>bit</c> is one and
+		/// <c>false</c> if it is zero. 
 		/// </summary>
 		public bool Get(int bit)
 		{
@@ -161,9 +161,9 @@ namespace Lucene.Net.Util
 		private static readonly byte[] BYTE_COUNTS = new byte[]{0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8};
 		
 		
-		/// <summary>Writes this vector to the file <code>name</code> in Directory
-		/// <code>d</code>, in a format that can be read by the constructor {@link
-		/// #BitVector(Directory, String)}.  
+		/// <summary>Writes this vector to the file <c>name</c> in Directory
+		/// <c>d</c>, in a format that can be read by the constructor 
+		/// <see cref="BitVector(Directory, String)" />.  
 		/// </summary>
 		public void  Write(Directory d, System.String name)
 		{
@@ -236,8 +236,8 @@ namespace Lucene.Net.Util
 			return factor * (4 + (8 + 40) * Count()) < Size();
 		}
 		
-		/// <summary>Constructs a bit vector from the file <code>name</code> in Directory
-		/// <code>d</code>, as written by the {@link #write} method.
+		/// <summary>Constructs a bit vector from the file <c>name</c> in Directory
+		/// <c>d</c>, as written by the <see cref="Write" /> method.
 		/// </summary>
 		public BitVector(Directory d, System.String name)
 		{

Modified: incubator/lucene.net/trunk/src/core/Util/Cache/Cache.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/Cache/Cache.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/Cache/Cache.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/Cache/Cache.cs Sun Nov  6 05:24:26 2011
@@ -92,10 +92,10 @@ namespace Lucene.Net.Util.Cache
 			return cache.GetSynchronizedCache();
 		}
 		
-		/// <summary> Called by {@link #SynchronizedCache(Cache)}. This method
-		/// returns a {@link SynchronizedCache} instance that wraps
+		/// <summary> Called by <see cref="SynchronizedCache(Cache)" />. This method
+		/// returns a <see cref="SynchronizedCache" /> instance that wraps
 		/// this instance by default and can be overridden to return
-		/// e. g. subclasses of {@link SynchronizedCache} or this
+		/// e. g. subclasses of <see cref="SynchronizedCache" /> or this
 		/// in case this cache is already synchronized.
 		/// </summary>
 		internal virtual Cache GetSynchronizedCache()

Modified: incubator/lucene.net/trunk/src/core/Util/Cache/SimpleLRUCache.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/Cache/SimpleLRUCache.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/Cache/SimpleLRUCache.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/Cache/SimpleLRUCache.cs Sun Nov  6 05:24:26 2011
@@ -116,7 +116,7 @@ namespace Lucene.Net.Util.Cache
   
 
 	/// <summary> Simple LRU cache implementation that uses a LinkedHashMap.
-	/// This cache is not synchronized, use {@link Cache#SynchronizedCache(Cache)}
+	/// This cache is not synchronized, use <see cref="Cache.SynchronizedCache(Cache)" />
 	/// if needed.
 	/// 
 	/// </summary>

Modified: incubator/lucene.net/trunk/src/core/Util/Cache/SimpleMapCache.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/Cache/SimpleMapCache.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/Cache/SimpleMapCache.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/Cache/SimpleMapCache.cs Sun Nov  6 05:24:26 2011
@@ -21,7 +21,7 @@ namespace Lucene.Net.Util.Cache
 {
 	
 	/// <summary> Simple cache implementation that uses a HashMap to store (key, value) pairs.
-	/// This cache is not synchronized, use {@link Cache#SynchronizedCache(Cache)}
+	/// This cache is not synchronized, use <see cref="Cache.SynchronizedCache(Cache)" />
 	/// if needed.
 	/// </summary>
 	public class SimpleMapCache:Cache



Mime
View raw message