lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ccurr...@apache.org
Subject [22/51] [partial] Mass convert mixed tabs to spaces
Date Wed, 03 Apr 2013 17:40:05 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/core/Document/AbstractField.cs
----------------------------------------------------------------------
diff --git a/src/core/Document/AbstractField.cs b/src/core/Document/AbstractField.cs
index a526f1d..0cfbf5d 100644
--- a/src/core/Document/AbstractField.cs
+++ b/src/core/Document/AbstractField.cs
@@ -24,289 +24,289 @@ using SpanQuery = Lucene.Net.Search.Spans.SpanQuery;
 
 namespace Lucene.Net.Documents
 {
-	/// <summary> 
-	/// 
-	/// 
-	/// </summary>
-	[Serializable]
-	public abstract class AbstractField : IFieldable
-	{
-		
-		protected internal System.String internalName = "body";
-		protected internal bool storeTermVector = false;
-		protected internal bool storeOffsetWithTermVector = false;
-		protected internal bool storePositionWithTermVector = false;
-		protected internal bool internalOmitNorms = false;
-		protected internal bool internalIsStored = false;
-		protected internal bool internalIsIndexed = true;
-		protected internal bool internalIsTokenized = true;
-		protected internal bool internalIsBinary = false;
-		protected internal bool lazy = false;
-		protected internal bool internalOmitTermFreqAndPositions = false;
-		protected internal float internalBoost = 1.0f;
-		// the data object for all different kind of field values
-		protected internal System.Object fieldsData = null;
-		// pre-analyzed tokenStream for indexed fields
-		protected internal TokenStream tokenStream;
-		// length/offset for all primitive types
-		protected internal int internalBinaryLength;
-		protected internal int internalbinaryOffset;
-		
-		protected internal AbstractField()
-		{
-		}
-		
-		protected internal AbstractField(System.String name, Field.Store store, Field.Index index, Field.TermVector termVector)
-		{
-			if (name == null)
-				throw new System.NullReferenceException("name cannot be null");
-			this.internalName = StringHelper.Intern(name); // field names are interned
+    /// <summary> 
+    /// 
+    /// 
+    /// </summary>
+    [Serializable]
+    public abstract class AbstractField : IFieldable
+    {
+        
+        protected internal System.String internalName = "body";
+        protected internal bool storeTermVector = false;
+        protected internal bool storeOffsetWithTermVector = false;
+        protected internal bool storePositionWithTermVector = false;
+        protected internal bool internalOmitNorms = false;
+        protected internal bool internalIsStored = false;
+        protected internal bool internalIsIndexed = true;
+        protected internal bool internalIsTokenized = true;
+        protected internal bool internalIsBinary = false;
+        protected internal bool lazy = false;
+        protected internal bool internalOmitTermFreqAndPositions = false;
+        protected internal float internalBoost = 1.0f;
+        // the data object for all different kind of field values
+        protected internal System.Object fieldsData = null;
+        // pre-analyzed tokenStream for indexed fields
+        protected internal TokenStream tokenStream;
+        // length/offset for all primitive types
+        protected internal int internalBinaryLength;
+        protected internal int internalbinaryOffset;
+        
+        protected internal AbstractField()
+        {
+        }
+        
+        protected internal AbstractField(System.String name, Field.Store store, Field.Index index, Field.TermVector termVector)
+        {
+            if (name == null)
+                throw new System.NullReferenceException("name cannot be null");
+            this.internalName = StringHelper.Intern(name); // field names are interned
 
-		    this.internalIsStored = store.IsStored();
-		    this.internalIsIndexed = index.IsIndexed();
-		    this.internalIsTokenized = index.IsAnalyzed();
-		    this.internalOmitNorms = index.OmitNorms();
-			
-			this.internalIsBinary = false;
-			
-			SetStoreTermVector(termVector);
-		}
+            this.internalIsStored = store.IsStored();
+            this.internalIsIndexed = index.IsIndexed();
+            this.internalIsTokenized = index.IsAnalyzed();
+            this.internalOmitNorms = index.OmitNorms();
+            
+            this.internalIsBinary = false;
+            
+            SetStoreTermVector(termVector);
+        }
 
-	    /// <summary>Gets or sets the boost factor for hits for this field.
-	    /// 
-	    /// <p/>The default value is 1.0.
-	    /// 
-	    /// <p/>Note: this value is not stored directly with the document in the index.
-	    /// Documents returned from <see cref="Lucene.Net.Index.IndexReader.Document(int)" /> and
-	    /// <see cref="Lucene.Net.Search.Searcher.Doc(int)" /> may thus not have the same value present as when
-	    /// this field was indexed.
-	    /// </summary>
-	    public virtual float Boost
-	    {
-	        get { return internalBoost; }
-	        set { this.internalBoost = value; }
-	    }
+        /// <summary>Gets or sets the boost factor for hits for this field.
+        /// 
+        /// <p/>The default value is 1.0.
+        /// 
+        /// <p/>Note: this value is not stored directly with the document in the index.
+        /// Documents returned from <see cref="Lucene.Net.Index.IndexReader.Document(int)" /> and
+        /// <see cref="Lucene.Net.Search.Searcher.Doc(int)" /> may thus not have the same value present as when
+        /// this field was indexed.
+        /// </summary>
+        public virtual float Boost
+        {
+            get { return internalBoost; }
+            set { this.internalBoost = value; }
+        }
 
-	    /// <summary>Returns the name of the field as an interned string.
-	    /// For example "date", "title", "body", ...
-	    /// </summary>
-	    public virtual string Name
-	    {
-	        get { return internalName; }
-	    }
+        /// <summary>Returns the name of the field as an interned string.
+        /// For example "date", "title", "body", ...
+        /// </summary>
+        public virtual string Name
+        {
+            get { return internalName; }
+        }
 
-	    protected internal virtual void  SetStoreTermVector(Field.TermVector termVector)
-		{
-		    this.storeTermVector = termVector.IsStored();
-		    this.storePositionWithTermVector = termVector.WithPositions();
-		    this.storeOffsetWithTermVector = termVector.WithOffsets();
-		}
+        protected internal virtual void  SetStoreTermVector(Field.TermVector termVector)
+        {
+            this.storeTermVector = termVector.IsStored();
+            this.storePositionWithTermVector = termVector.WithPositions();
+            this.storeOffsetWithTermVector = termVector.WithOffsets();
+        }
 
-	    /// <summary>True iff the value of the field is to be stored in the index for return
-	    /// with search hits.  It is an error for this to be true if a field is
-	    /// Reader-valued. 
-	    /// </summary>
-	    public bool IsStored
-	    {
-	        get { return internalIsStored; }
-	    }
+        /// <summary>True iff the value of the field is to be stored in the index for return
+        /// with search hits.  It is an error for this to be true if a field is
+        /// Reader-valued. 
+        /// </summary>
+        public bool IsStored
+        {
+            get { return internalIsStored; }
+        }
 
-	    /// <summary>True iff the value of the field is to be indexed, so that it may be
-	    /// searched on. 
-	    /// </summary>
-	    public bool IsIndexed
-	    {
-	        get { return internalIsIndexed; }
-	    }
+        /// <summary>True iff the value of the field is to be indexed, so that it may be
+        /// searched on. 
+        /// </summary>
+        public bool IsIndexed
+        {
+            get { return internalIsIndexed; }
+        }
 
-	    /// <summary>True iff the value of the field should be tokenized as text prior to
-	    /// indexing.  Un-tokenized fields are indexed as a single word and may not be
-	    /// Reader-valued. 
-	    /// </summary>
-	    public bool IsTokenized
-	    {
-	        get { return internalIsTokenized; }
-	    }
+        /// <summary>True iff the value of the field should be tokenized as text prior to
+        /// indexing.  Un-tokenized fields are indexed as a single word and may not be
+        /// Reader-valued. 
+        /// </summary>
+        public bool IsTokenized
+        {
+            get { return internalIsTokenized; }
+        }
 
-	    /// <summary>True iff the term or terms used to index this field are stored as a term
-	    /// vector, available from <see cref="Lucene.Net.Index.IndexReader.GetTermFreqVector(int,String)" />.
-	    /// These methods do not provide access to the original content of the field,
-	    /// only to terms used to index it. If the original content must be
-	    /// preserved, use the <c>stored</c> attribute instead.
-	    /// 
-	    /// </summary>
-	    /// <seealso cref="Lucene.Net.Index.IndexReader.GetTermFreqVector(int, String)">
-	    /// </seealso>
-	    public bool IsTermVectorStored
-	    {
-	        get { return storeTermVector; }
-	    }
+        /// <summary>True iff the term or terms used to index this field are stored as a term
+        /// vector, available from <see cref="Lucene.Net.Index.IndexReader.GetTermFreqVector(int,String)" />.
+        /// These methods do not provide access to the original content of the field,
+        /// only to terms used to index it. If the original content must be
+        /// preserved, use the <c>stored</c> attribute instead.
+        /// 
+        /// </summary>
+        /// <seealso cref="Lucene.Net.Index.IndexReader.GetTermFreqVector(int, String)">
+        /// </seealso>
+        public bool IsTermVectorStored
+        {
+            get { return storeTermVector; }
+        }
 
-	    /// <summary> True iff terms are stored as term vector together with their offsets 
-	    /// (start and end position in source text).
-	    /// </summary>
-	    public virtual bool IsStoreOffsetWithTermVector
-	    {
-	        get { return storeOffsetWithTermVector; }
-	    }
+        /// <summary> True iff terms are stored as term vector together with their offsets 
+        /// (start and end position in source text).
+        /// </summary>
+        public virtual bool IsStoreOffsetWithTermVector
+        {
+            get { return storeOffsetWithTermVector; }
+        }
 
-	    /// <summary> True iff terms are stored as term vector together with their token positions.</summary>
-	    public virtual bool IsStorePositionWithTermVector
-	    {
-	        get { return storePositionWithTermVector; }
-	    }
+        /// <summary> True iff terms are stored as term vector together with their token positions.</summary>
+        public virtual bool IsStorePositionWithTermVector
+        {
+            get { return storePositionWithTermVector; }
+        }
 
-	    /// <summary>True iff the value of the filed is stored as binary </summary>
-	    public bool IsBinary
-	    {
-	        get { return internalIsBinary; }
-	    }
+        /// <summary>True iff the value of the filed is stored as binary </summary>
+        public bool IsBinary
+        {
+            get { return internalIsBinary; }
+        }
 
 
-	    /// <summary> Return the raw byte[] for the binary field.  Note that
-	    /// you must also call <see cref="BinaryLength" /> and <see cref="BinaryOffset" />
-	    /// to know which range of bytes in this
-	    /// returned array belong to the field.
-	    /// </summary>
-	    /// <returns> reference to the Field value as byte[]. </returns>
-	    public virtual byte[] GetBinaryValue()
-	    {
-	        return GetBinaryValue(null);
-	    }
+        /// <summary> Return the raw byte[] for the binary field.  Note that
+        /// you must also call <see cref="BinaryLength" /> and <see cref="BinaryOffset" />
+        /// to know which range of bytes in this
+        /// returned array belong to the field.
+        /// </summary>
+        /// <returns> reference to the Field value as byte[]. </returns>
+        public virtual byte[] GetBinaryValue()
+        {
+            return GetBinaryValue(null);
+        }
 
-	    public virtual byte[] GetBinaryValue(byte[] result)
-		{
-			if (internalIsBinary || fieldsData is byte[])
-				return (byte[]) fieldsData;
-			else
-				return null;
-		}
+        public virtual byte[] GetBinaryValue(byte[] result)
+        {
+            if (internalIsBinary || fieldsData is byte[])
+                return (byte[]) fieldsData;
+            else
+                return null;
+        }
 
-	    /// <summary> Returns length of byte[] segment that is used as value, if Field is not binary
-	    /// returned value is undefined
-	    /// </summary>
-	    /// <value> length of byte[] segment that represents this Field value </value>
-	    public virtual int BinaryLength
-	    {
-	        get
-	        {
-	            if (internalIsBinary)
-	            {
-	                return internalBinaryLength;
-	            }
-	            return fieldsData is byte[] ? ((byte[]) fieldsData).Length : 0;
-	        }
-	    }
+        /// <summary> Returns length of byte[] segment that is used as value, if Field is not binary
+        /// returned value is undefined
+        /// </summary>
+        /// <value> length of byte[] segment that represents this Field value </value>
+        public virtual int BinaryLength
+        {
+            get
+            {
+                if (internalIsBinary)
+                {
+                    return internalBinaryLength;
+                }
+                return fieldsData is byte[] ? ((byte[]) fieldsData).Length : 0;
+            }
+        }
 
-	    /// <summary> Returns offset into byte[] segment that is used as value, if Field is not binary
-	    /// returned value is undefined
-	    /// </summary>
-	    /// <value> index of the first character in byte[] segment that represents this Field value </value>
-	    public virtual int BinaryOffset
-	    {
-	        get { return internalbinaryOffset; }
-	    }
+        /// <summary> Returns offset into byte[] segment that is used as value, if Field is not binary
+        /// returned value is undefined
+        /// </summary>
+        /// <value> index of the first character in byte[] segment that represents this Field value </value>
+        public virtual int BinaryOffset
+        {
+            get { return internalbinaryOffset; }
+        }
 
-	    /// <summary>True if norms are omitted for this indexed field </summary>
-	    public virtual bool OmitNorms
-	    {
-	        get { return internalOmitNorms; }
-	        set { this.internalOmitNorms = value; }
-	    }
+        /// <summary>True if norms are omitted for this indexed field </summary>
+        public virtual bool OmitNorms
+        {
+            get { return internalOmitNorms; }
+            set { this.internalOmitNorms = value; }
+        }
 
-	    /// <summary>Expert:
-	    /// 
-	    /// If set, omit term freq, positions and payloads from
-	    /// postings for this field.
-	    /// 
-	    /// <p/><b>NOTE</b>: While this option reduces storage space
-	    /// required in the index, it also means any query
-	    /// requiring positional information, such as <see cref="PhraseQuery" />
-	    /// or <see cref="SpanQuery" /> subclasses will
-	    /// silently fail to find results.
-	    /// </summary>
-	    public virtual bool OmitTermFreqAndPositions
-	    {
-	        set { this.internalOmitTermFreqAndPositions = value; }
-	        get { return internalOmitTermFreqAndPositions; }
-	    }
+        /// <summary>Expert:
+        /// 
+        /// If set, omit term freq, positions and payloads from
+        /// postings for this field.
+        /// 
+        /// <p/><b>NOTE</b>: While this option reduces storage space
+        /// required in the index, it also means any query
+        /// requiring positional information, such as <see cref="PhraseQuery" />
+        /// or <see cref="SpanQuery" /> subclasses will
+        /// silently fail to find results.
+        /// </summary>
+        public virtual bool OmitTermFreqAndPositions
+        {
+            set { this.internalOmitTermFreqAndPositions = value; }
+            get { return internalOmitTermFreqAndPositions; }
+        }
 
-	    public virtual bool IsLazy
-	    {
-	        get { return lazy; }
-	    }
+        public virtual bool IsLazy
+        {
+            get { return lazy; }
+        }
 
-	    /// <summary>Prints a Field for human consumption. </summary>
-		public override System.String ToString()
-		{
-			System.Text.StringBuilder result = new System.Text.StringBuilder();
-			if (internalIsStored)
-			{
-				result.Append("stored");
-			}
-			if (internalIsIndexed)
-			{
-				if (result.Length > 0)
-					result.Append(",");
-				result.Append("indexed");
-			}
-			if (internalIsTokenized)
-			{
-				if (result.Length > 0)
-					result.Append(",");
-				result.Append("tokenized");
-			}
-			if (storeTermVector)
-			{
-				if (result.Length > 0)
-					result.Append(",");
-				result.Append("termVector");
-			}
-			if (storeOffsetWithTermVector)
-			{
-				if (result.Length > 0)
-					result.Append(",");
-				result.Append("termVectorOffsets");
-			}
-			if (storePositionWithTermVector)
-			{
-				if (result.Length > 0)
-					result.Append(",");
-				result.Append("termVectorPosition");
-			}
-			if (internalIsBinary)
-			{
-				if (result.Length > 0)
-					result.Append(",");
-				result.Append("binary");
-			}
-			if (internalOmitNorms)
-			{
-				result.Append(",omitNorms");
-			}
-			if (internalOmitTermFreqAndPositions)
-			{
-				result.Append(",omitTermFreqAndPositions");
-			}
-			if (lazy)
-			{
-				result.Append(",lazy");
-			}
-			result.Append('<');
-			result.Append(internalName);
-			result.Append(':');
-			
-			if (fieldsData != null && lazy == false)
-			{
-				result.Append(fieldsData);
-			}
-			
-			result.Append('>');
-			return result.ToString();
-		}
+        /// <summary>Prints a Field for human consumption. </summary>
+        public override System.String ToString()
+        {
+            System.Text.StringBuilder result = new System.Text.StringBuilder();
+            if (internalIsStored)
+            {
+                result.Append("stored");
+            }
+            if (internalIsIndexed)
+            {
+                if (result.Length > 0)
+                    result.Append(",");
+                result.Append("indexed");
+            }
+            if (internalIsTokenized)
+            {
+                if (result.Length > 0)
+                    result.Append(",");
+                result.Append("tokenized");
+            }
+            if (storeTermVector)
+            {
+                if (result.Length > 0)
+                    result.Append(",");
+                result.Append("termVector");
+            }
+            if (storeOffsetWithTermVector)
+            {
+                if (result.Length > 0)
+                    result.Append(",");
+                result.Append("termVectorOffsets");
+            }
+            if (storePositionWithTermVector)
+            {
+                if (result.Length > 0)
+                    result.Append(",");
+                result.Append("termVectorPosition");
+            }
+            if (internalIsBinary)
+            {
+                if (result.Length > 0)
+                    result.Append(",");
+                result.Append("binary");
+            }
+            if (internalOmitNorms)
+            {
+                result.Append(",omitNorms");
+            }
+            if (internalOmitTermFreqAndPositions)
+            {
+                result.Append(",omitTermFreqAndPositions");
+            }
+            if (lazy)
+            {
+                result.Append(",lazy");
+            }
+            result.Append('<');
+            result.Append(internalName);
+            result.Append(':');
+            
+            if (fieldsData != null && lazy == false)
+            {
+                result.Append(fieldsData);
+            }
+            
+            result.Append('>');
+            return result.ToString();
+        }
 
-	    public abstract TokenStream TokenStreamValue { get; }
-	    public abstract TextReader ReaderValue { get; }
-	    public abstract string StringValue { get; }
-	}
+        public abstract TokenStream TokenStreamValue { get; }
+        public abstract TextReader ReaderValue { get; }
+        public abstract string StringValue { get; }
+    }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/core/Document/CompressionTools.cs
----------------------------------------------------------------------
diff --git a/src/core/Document/CompressionTools.cs b/src/core/Document/CompressionTools.cs
index 400633f..aaa3aae 100644
--- a/src/core/Document/CompressionTools.cs
+++ b/src/core/Document/CompressionTools.cs
@@ -27,124 +27,124 @@ using UnicodeUtil = Lucene.Net.Util.UnicodeUtil;
 
 namespace Lucene.Net.Documents
 {
-	
-	/// <summary>Simple utility class providing static methods to
-	/// compress and decompress binary data for stored fields.
-	/// This class uses java.util.zip.Deflater and Inflater
-	/// classes to compress and decompress.
-	/// </summary>
-	
-	public class CompressionTools
-	{
-		
-		// Export only static methods
-		private CompressionTools()
-		{
-		}
-		
-		/// <summary>Compresses the specified byte range using the
-		/// specified compressionLevel (constants are defined in
-		/// java.util.zip.Deflater). 
-		/// </summary>
-		public static byte[] Compress(byte[] value_Renamed, int offset, int length, int compressionLevel)
-		{
-			/* Create an expandable byte array to hold the compressed data.
-			* You cannot use an array that's the same size as the orginal because
-			* there is no guarantee that the compressed data will be smaller than
-			* the uncompressed data. */
-			System.IO.MemoryStream bos = new System.IO.MemoryStream(length);
+    
+    /// <summary>Simple utility class providing static methods to
+    /// compress and decompress binary data for stored fields.
+    /// This class uses java.util.zip.Deflater and Inflater
+    /// classes to compress and decompress.
+    /// </summary>
+    
+    public class CompressionTools
+    {
+        
+        // Export only static methods
+        private CompressionTools()
+        {
+        }
+        
+        /// <summary>Compresses the specified byte range using the
+        /// specified compressionLevel (constants are defined in
+        /// java.util.zip.Deflater). 
+        /// </summary>
+        public static byte[] Compress(byte[] value_Renamed, int offset, int length, int compressionLevel)
+        {
+            /* Create an expandable byte array to hold the compressed data.
+            * You cannot use an array that's the same size as the orginal because
+            * there is no guarantee that the compressed data will be smaller than
+            * the uncompressed data. */
+            System.IO.MemoryStream bos = new System.IO.MemoryStream(length);
 
             Deflater compressor = SharpZipLib.CreateDeflater();
-			
-			try
-			{
-				compressor.SetLevel(compressionLevel);
-				compressor.SetInput(value_Renamed, offset, length);
-				compressor.Finish();
-				
-				// Compress the data
-				byte[] buf = new byte[1024];
-				while (!compressor.IsFinished)
-				{
-					int count = compressor.Deflate(buf);
-					bos.Write(buf, 0, count);
-				}
-			}
-			finally
-			{
-			}
-			
-			return bos.ToArray();
-		}
-		
-		/// <summary>Compresses the specified byte range, with default BEST_COMPRESSION level </summary>
-		public static byte[] Compress(byte[] value_Renamed, int offset, int length)
+            
+            try
+            {
+                compressor.SetLevel(compressionLevel);
+                compressor.SetInput(value_Renamed, offset, length);
+                compressor.Finish();
+                
+                // Compress the data
+                byte[] buf = new byte[1024];
+                while (!compressor.IsFinished)
+                {
+                    int count = compressor.Deflate(buf);
+                    bos.Write(buf, 0, count);
+                }
+            }
+            finally
+            {
+            }
+            
+            return bos.ToArray();
+        }
+        
+        /// <summary>Compresses the specified byte range, with default BEST_COMPRESSION level </summary>
+        public static byte[] Compress(byte[] value_Renamed, int offset, int length)
+        {
+            return Compress(value_Renamed, offset, length, Deflater.BEST_COMPRESSION);
+        }
+        
+        /// <summary>Compresses all bytes in the array, with default BEST_COMPRESSION level </summary>
+        public static byte[] Compress(byte[] value_Renamed)
         {
-			return Compress(value_Renamed, offset, length, Deflater.BEST_COMPRESSION);
-		}
-		
-		/// <summary>Compresses all bytes in the array, with default BEST_COMPRESSION level </summary>
-		public static byte[] Compress(byte[] value_Renamed)
-		{
             return Compress(value_Renamed, 0, value_Renamed.Length, Deflater.BEST_COMPRESSION);
-		}
-		
-		/// <summary>Compresses the String value, with default BEST_COMPRESSION level </summary>
-		public static byte[] CompressString(System.String value_Renamed)
-		{
+        }
+        
+        /// <summary>Compresses the String value, with default BEST_COMPRESSION level </summary>
+        public static byte[] CompressString(System.String value_Renamed)
+        {
             return CompressString(value_Renamed, Deflater.BEST_COMPRESSION);
-		}
-		
-		/// <summary>Compresses the String value using the specified
-		/// compressionLevel (constants are defined in
-		/// java.util.zip.Deflater). 
-		/// </summary>
-		public static byte[] CompressString(System.String value_Renamed, int compressionLevel)
-		{
-			UnicodeUtil.UTF8Result result = new UnicodeUtil.UTF8Result();
-			UnicodeUtil.UTF16toUTF8(value_Renamed, 0, value_Renamed.Length, result);
-			return Compress(result.result, 0, result.length, compressionLevel);
-		}
-		
-		/// <summary>Decompress the byte array previously returned by
-		/// compress 
-		/// </summary>
-		public static byte[] Decompress(byte[] value_Renamed)
-		{
-			// Create an expandable byte array to hold the decompressed data
-			System.IO.MemoryStream bos = new System.IO.MemoryStream(value_Renamed.Length);
-			
-			Inflater decompressor = SharpZipLib.CreateInflater();
-			
-			try
-			{
-				decompressor.SetInput(value_Renamed);
-				
-				// Decompress the data
-				byte[] buf = new byte[1024];
-				while (!decompressor.IsFinished)
-				{
-					int count = decompressor.Inflate(buf);
-					bos.Write(buf, 0, count);
-				}
-			}
-			finally
-			{
-			}
-			
-			return bos.ToArray();
-		}
-		
-		/// <summary>Decompress the byte array previously returned by
-		/// compressString back into a String 
-		/// </summary>
-		public static System.String DecompressString(byte[] value_Renamed)
-		{
-			UnicodeUtil.UTF16Result result = new UnicodeUtil.UTF16Result();
-			byte[] bytes = Decompress(value_Renamed);
-			UnicodeUtil.UTF8toUTF16(bytes, 0, bytes.Length, result);
-			return new System.String(result.result, 0, result.length);
-		}
-	}
+        }
+        
+        /// <summary>Compresses the String value using the specified
+        /// compressionLevel (constants are defined in
+        /// java.util.zip.Deflater). 
+        /// </summary>
+        public static byte[] CompressString(System.String value_Renamed, int compressionLevel)
+        {
+            UnicodeUtil.UTF8Result result = new UnicodeUtil.UTF8Result();
+            UnicodeUtil.UTF16toUTF8(value_Renamed, 0, value_Renamed.Length, result);
+            return Compress(result.result, 0, result.length, compressionLevel);
+        }
+        
+        /// <summary>Decompress the byte array previously returned by
+        /// compress 
+        /// </summary>
+        public static byte[] Decompress(byte[] value_Renamed)
+        {
+            // Create an expandable byte array to hold the decompressed data
+            System.IO.MemoryStream bos = new System.IO.MemoryStream(value_Renamed.Length);
+            
+            Inflater decompressor = SharpZipLib.CreateInflater();
+            
+            try
+            {
+                decompressor.SetInput(value_Renamed);
+                
+                // Decompress the data
+                byte[] buf = new byte[1024];
+                while (!decompressor.IsFinished)
+                {
+                    int count = decompressor.Inflate(buf);
+                    bos.Write(buf, 0, count);
+                }
+            }
+            finally
+            {
+            }
+            
+            return bos.ToArray();
+        }
+        
+        /// <summary>Decompress the byte array previously returned by
+        /// compressString back into a String 
+        /// </summary>
+        public static System.String DecompressString(byte[] value_Renamed)
+        {
+            UnicodeUtil.UTF16Result result = new UnicodeUtil.UTF16Result();
+            byte[] bytes = Decompress(value_Renamed);
+            UnicodeUtil.UTF8toUTF16(bytes, 0, bytes.Length, result);
+            return new System.String(result.result, 0, result.length);
+        }
+    }
 }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/core/Document/DateField.cs
----------------------------------------------------------------------
diff --git a/src/core/Document/DateField.cs b/src/core/Document/DateField.cs
index 6179f4c..219c7d9 100644
--- a/src/core/Document/DateField.cs
+++ b/src/core/Document/DateField.cs
@@ -25,107 +25,107 @@ using TermRangeQuery = Lucene.Net.Search.TermRangeQuery;
 
 namespace Lucene.Net.Documents
 {
-	// for javadoc
-	
-	// do not remove in 3.0, needed for reading old indexes!
-	
-	/// <summary> Provides support for converting dates to strings and vice-versa.
-	/// The strings are structured so that lexicographic sorting orders by date,
-	/// which makes them suitable for use as field values and search terms.
-	/// 
-	/// <p/>Note that this class saves dates with millisecond granularity,
-	/// which is bad for <see cref="TermRangeQuery" /> and <see cref="PrefixQuery" />, as those
-	/// queries are expanded to a BooleanQuery with a potentially large number
-	/// of terms when searching. Thus you might want to use
-	/// <see cref="DateTools" /> instead.
-	/// 
-	/// <p/>
-	/// Note: dates before 1970 cannot be used, and therefore cannot be
-	/// indexed when using this class. See <see cref="DateTools" /> for an
-	/// alternative without such a limitation.
-	/// 
-	/// <p/>
-	/// Another approach is <see cref="NumericUtils" />, which provides
-	/// a sortable binary representation (prefix encoded) of numeric values, which
-	/// date/time are.
-	/// For indexing a <see cref="DateTime" />, convert it to unix timestamp as
-	/// <c>long</c> and
-	/// index this as a numeric value with <see cref="NumericField" />
-	/// and use <see cref="NumericRangeQuery{T}" /> to query it.
-	/// 
-	/// </summary>
-	/// <deprecated> If you build a new index, use <see cref="DateTools" /> or 
-	/// <see cref="NumericField" /> instead.
-	/// This class is included for use with existing
-	/// indices and will be removed in a future (possibly Lucene 4.0)
-	/// </deprecated>
+    // for javadoc
+    
+    // do not remove in 3.0, needed for reading old indexes!
+    
+    /// <summary> Provides support for converting dates to strings and vice-versa.
+    /// The strings are structured so that lexicographic sorting orders by date,
+    /// which makes them suitable for use as field values and search terms.
+    /// 
+    /// <p/>Note that this class saves dates with millisecond granularity,
+    /// which is bad for <see cref="TermRangeQuery" /> and <see cref="PrefixQuery" />, as those
+    /// queries are expanded to a BooleanQuery with a potentially large number
+    /// of terms when searching. Thus you might want to use
+    /// <see cref="DateTools" /> instead.
+    /// 
+    /// <p/>
+    /// Note: dates before 1970 cannot be used, and therefore cannot be
+    /// indexed when using this class. See <see cref="DateTools" /> for an
+    /// alternative without such a limitation.
+    /// 
+    /// <p/>
+    /// Another approach is <see cref="NumericUtils" />, which provides
+    /// a sortable binary representation (prefix encoded) of numeric values, which
+    /// date/time are.
+    /// For indexing a <see cref="DateTime" />, convert it to unix timestamp as
+    /// <c>long</c> and
+    /// index this as a numeric value with <see cref="NumericField" />
+    /// and use <see cref="NumericRangeQuery{T}" /> to query it.
+    /// 
+    /// </summary>
+    /// <deprecated> If you build a new index, use <see cref="DateTools" /> or 
+    /// <see cref="NumericField" /> instead.
+    /// This class is included for use with existing
+    /// indices and will be removed in a future (possibly Lucene 4.0)
+    /// </deprecated>
     [Obsolete("If you build a new index, use DateTools or NumericField instead.This class is included for use with existing indices and will be removed in a future release (possibly Lucene 4.0).")]
-	public class DateField
-	{
-		
-		private DateField()
-		{
-		}
-		
-		// make date strings long enough to last a millenium
+    public class DateField
+    {
+        
+        private DateField()
+        {
+        }
+        
+        // make date strings long enough to last a millenium
         private static int DATE_LEN = Number.ToString(1000L * 365 * 24 * 60 * 60 * 1000, Number.MAX_RADIX).Length;
 
-		public static System.String MIN_DATE_STRING()
-		{
-			return TimeToString(0);
-		}
-		
-		public static System.String MAX_DATE_STRING()
-		{
-			char[] buffer = new char[DATE_LEN];
+        public static System.String MIN_DATE_STRING()
+        {
+            return TimeToString(0);
+        }
+        
+        public static System.String MAX_DATE_STRING()
+        {
+            char[] buffer = new char[DATE_LEN];
             char c = Character.ForDigit(Character.MAX_RADIX - 1, Character.MAX_RADIX);
-			for (int i = 0; i < DATE_LEN; i++)
-				buffer[i] = c;
-			return new System.String(buffer);
-		}
-		
-		/// <summary> Converts a Date to a string suitable for indexing.</summary>
-		/// <throws>  RuntimeException if the date specified in the </throws>
-		/// <summary> method argument is before 1970
-		/// </summary>
+            for (int i = 0; i < DATE_LEN; i++)
+                buffer[i] = c;
+            return new System.String(buffer);
+        }
+        
+        /// <summary> Converts a Date to a string suitable for indexing.</summary>
+        /// <throws>  RuntimeException if the date specified in the </throws>
+        /// <summary> method argument is before 1970
+        /// </summary>
         public static System.String DateToString(System.DateTime date)
         {
             TimeSpan ts = date.Subtract(new DateTime(1970, 1, 1));
             ts = ts.Subtract(TimeZone.CurrentTimeZone.GetUtcOffset(date));
             return TimeToString(ts.Ticks / TimeSpan.TicksPerMillisecond);
         }
-		/// <summary> Converts a millisecond time to a string suitable for indexing.</summary>
-		/// <throws>  RuntimeException if the time specified in the </throws>
-		/// <summary> method argument is negative, that is, before 1970
-		/// </summary>
-		public static System.String TimeToString(long time)
-		{
-			if (time < 0)
-				throw new System.SystemException("time '" + time + "' is too early, must be >= 0");
+        /// <summary> Converts a millisecond time to a string suitable for indexing.</summary>
+        /// <throws>  RuntimeException if the time specified in the </throws>
+        /// <summary> method argument is negative, that is, before 1970
+        /// </summary>
+        public static System.String TimeToString(long time)
+        {
+            if (time < 0)
+                throw new System.SystemException("time '" + time + "' is too early, must be >= 0");
 
             System.String s = Number.ToString(time, Character.MAX_RADIX);
-			
-			if (s.Length > DATE_LEN)
-				throw new System.SystemException("time '" + time + "' is too late, length of string " + "representation must be <= " + DATE_LEN);
-			
-			// Pad with leading zeros
-			if (s.Length < DATE_LEN)
-			{
-				System.Text.StringBuilder sb = new System.Text.StringBuilder(s);
-				while (sb.Length < DATE_LEN)
-					sb.Insert(0, 0);
-				s = sb.ToString();
-			}
-			
-			return s;
-		}
-		
-		/// <summary>Converts a string-encoded date into a millisecond time. </summary>
-		public static long StringToTime(System.String s)
-		{
+            
+            if (s.Length > DATE_LEN)
+                throw new System.SystemException("time '" + time + "' is too late, length of string " + "representation must be <= " + DATE_LEN);
+            
+            // Pad with leading zeros
+            if (s.Length < DATE_LEN)
+            {
+                System.Text.StringBuilder sb = new System.Text.StringBuilder(s);
+                while (sb.Length < DATE_LEN)
+                    sb.Insert(0, 0);
+                s = sb.ToString();
+            }
+            
+            return s;
+        }
+        
+        /// <summary>Converts a string-encoded date into a millisecond time. </summary>
+        public static long StringToTime(System.String s)
+        {
             return Number.Parse(s, Number.MAX_RADIX);
-		}
-		/// <summary>Converts a string-encoded date into a Date object. </summary>
+        }
+        /// <summary>Converts a string-encoded date into a Date object. </summary>
         public static System.DateTime StringToDate(System.String s)
         {
             long ticks = StringToTime(s) * TimeSpan.TicksPerMillisecond;
@@ -134,5 +134,5 @@ namespace Lucene.Net.Documents
             date = date.Add(TimeZone.CurrentTimeZone.GetUtcOffset(date));
             return date;
         }
-	}
+    }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/core/Document/DateTools.cs
----------------------------------------------------------------------
diff --git a/src/core/Document/DateTools.cs b/src/core/Document/DateTools.cs
index 8263df1..6e2af27 100644
--- a/src/core/Document/DateTools.cs
+++ b/src/core/Document/DateTools.cs
@@ -21,32 +21,32 @@ using NumericUtils = Lucene.Net.Util.NumericUtils;
 
 namespace Lucene.Net.Documents
 {
-	
-	/// <summary> Provides support for converting dates to strings and vice-versa.
-	/// The strings are structured so that lexicographic sorting orders 
-	/// them by date, which makes them suitable for use as field values 
-	/// and search terms.
-	/// 
-	/// <p/>This class also helps you to limit the resolution of your dates. Do not
-	/// save dates with a finer resolution than you really need, as then
-	/// RangeQuery and PrefixQuery will require more memory and become slower.
-	/// 
-	/// <p/>Compared to <see cref="DateField" /> the strings generated by the methods
-	/// in this class take slightly more space, unless your selected resolution
-	/// is set to <c>Resolution.DAY</c> or lower.
-	/// 
-	/// <p/>
-	/// Another approach is <see cref="NumericUtils" />, which provides
-	/// a sortable binary representation (prefix encoded) of numeric values, which
-	/// date/time are.
+    
+    /// <summary> Provides support for converting dates to strings and vice-versa.
+    /// The strings are structured so that lexicographic sorting orders 
+    /// them by date, which makes them suitable for use as field values 
+    /// and search terms.
+    /// 
+    /// <p/>This class also helps you to limit the resolution of your dates. Do not
+    /// save dates with a finer resolution than you really need, as then
+    /// RangeQuery and PrefixQuery will require more memory and become slower.
+    /// 
+    /// <p/>Compared to <see cref="DateField" /> the strings generated by the methods
+    /// in this class take slightly more space, unless your selected resolution
+    /// is set to <c>Resolution.DAY</c> or lower.
+    /// 
+    /// <p/>
+    /// Another approach is <see cref="NumericUtils" />, which provides
+    /// a sortable binary representation (prefix encoded) of numeric values, which
+    /// date/time are.
     /// For indexing a <see cref="DateTime" />, convert it to unix timestamp as
-	/// <c>long</c> and
-	/// index this as a numeric value with <see cref="NumericField" />
-	/// and use <see cref="NumericRangeQuery{T}" /> to query it.
-	/// </summary>
-	public class DateTools
-	{
-		
+    /// <c>long</c> and
+    /// index this as a numeric value with <see cref="NumericField" />
+    /// and use <see cref="NumericRangeQuery{T}" /> to query it.
+    /// </summary>
+    public class DateTools
+    {
+        
         private static readonly System.String YEAR_FORMAT = "yyyy";
         private static readonly System.String MONTH_FORMAT = "yyyyMM";
         private static readonly System.String DAY_FORMAT = "yyyyMMdd";
@@ -54,108 +54,108 @@ namespace Lucene.Net.Documents
         private static readonly System.String MINUTE_FORMAT = "yyyyMMddHHmm";
         private static readonly System.String SECOND_FORMAT = "yyyyMMddHHmmss";
         private static readonly System.String MILLISECOND_FORMAT = "yyyyMMddHHmmssfff";
-		
-		private static readonly System.Globalization.Calendar calInstance = new System.Globalization.GregorianCalendar();
-		
-		// cannot create, the class has static methods only
-		private DateTools()
-		{
-		}
-		
-		/// <summary> Converts a Date to a string suitable for indexing.
-		/// 
-		/// </summary>
-		/// <param name="date">the date to be converted
-		/// </param>
-		/// <param name="resolution">the desired resolution, see
-		/// <see cref="Round(DateTime, DateTools.Resolution)" />
-		/// </param>
-		/// <returns> a string in format <c>yyyyMMddHHmmssSSS</c> or shorter,
-		/// depending on <c>resolution</c>; using GMT as timezone 
-		/// </returns>
-		public static System.String DateToString(System.DateTime date, Resolution resolution)
-		{
-			return TimeToString(date.Ticks / TimeSpan.TicksPerMillisecond, resolution);
-		}
-		
-		/// <summary> Converts a millisecond time to a string suitable for indexing.
-		/// 
-		/// </summary>
-		/// <param name="time">the date expressed as milliseconds since January 1, 1970, 00:00:00 GMT
-		/// </param>
-		/// <param name="resolution">the desired resolution, see
-		/// <see cref="Round(long, DateTools.Resolution)" />
-		/// </param>
-		/// <returns> a string in format <c>yyyyMMddHHmmssSSS</c> or shorter,
-		/// depending on <c>resolution</c>; using GMT as timezone
-		/// </returns>
-		public static System.String TimeToString(long time, Resolution resolution)
-		{
+        
+        private static readonly System.Globalization.Calendar calInstance = new System.Globalization.GregorianCalendar();
+        
+        // cannot create, the class has static methods only
+        private DateTools()
+        {
+        }
+        
+        /// <summary> Converts a Date to a string suitable for indexing.
+        /// 
+        /// </summary>
+        /// <param name="date">the date to be converted
+        /// </param>
+        /// <param name="resolution">the desired resolution, see
+        /// <see cref="Round(DateTime, DateTools.Resolution)" />
+        /// </param>
+        /// <returns> a string in format <c>yyyyMMddHHmmssSSS</c> or shorter,
+        /// depending on <c>resolution</c>; using GMT as timezone 
+        /// </returns>
+        public static System.String DateToString(System.DateTime date, Resolution resolution)
+        {
+            return TimeToString(date.Ticks / TimeSpan.TicksPerMillisecond, resolution);
+        }
+        
+        /// <summary> Converts a millisecond time to a string suitable for indexing.
+        /// 
+        /// </summary>
+        /// <param name="time">the date expressed as milliseconds since January 1, 1970, 00:00:00 GMT
+        /// </param>
+        /// <param name="resolution">the desired resolution, see
+        /// <see cref="Round(long, DateTools.Resolution)" />
+        /// </param>
+        /// <returns> a string in format <c>yyyyMMddHHmmssSSS</c> or shorter,
+        /// depending on <c>resolution</c>; using GMT as timezone
+        /// </returns>
+        public static System.String TimeToString(long time, Resolution resolution)
+        {
             System.DateTime date = new System.DateTime(Round(time, resolution));
-			
-			if (resolution == Resolution.YEAR)
-			{
+            
+            if (resolution == Resolution.YEAR)
+            {
                 return date.ToString(YEAR_FORMAT, System.Globalization.CultureInfo.InvariantCulture);
-			}
-			else if (resolution == Resolution.MONTH)
-			{
+            }
+            else if (resolution == Resolution.MONTH)
+            {
                 return date.ToString(MONTH_FORMAT, System.Globalization.CultureInfo.InvariantCulture);
-			}
-			else if (resolution == Resolution.DAY)
-			{
+            }
+            else if (resolution == Resolution.DAY)
+            {
                 return date.ToString(DAY_FORMAT, System.Globalization.CultureInfo.InvariantCulture);
-			}
-			else if (resolution == Resolution.HOUR)
-			{
+            }
+            else if (resolution == Resolution.HOUR)
+            {
                 return date.ToString(HOUR_FORMAT, System.Globalization.CultureInfo.InvariantCulture);
-			}
-			else if (resolution == Resolution.MINUTE)
-			{
+            }
+            else if (resolution == Resolution.MINUTE)
+            {
                 return date.ToString(MINUTE_FORMAT, System.Globalization.CultureInfo.InvariantCulture);
-			}
-			else if (resolution == Resolution.SECOND)
-			{
+            }
+            else if (resolution == Resolution.SECOND)
+            {
                 return date.ToString(SECOND_FORMAT, System.Globalization.CultureInfo.InvariantCulture);
-			}
-			else if (resolution == Resolution.MILLISECOND)
-			{
+            }
+            else if (resolution == Resolution.MILLISECOND)
+            {
                 return date.ToString(MILLISECOND_FORMAT, System.Globalization.CultureInfo.InvariantCulture);
-			}
-			
-			throw new System.ArgumentException("unknown resolution " + resolution);
-		}
-		
-		/// <summary> Converts a string produced by <c>timeToString</c> or
-		/// <c>DateToString</c> back to a time, represented as the
-		/// number of milliseconds since January 1, 1970, 00:00:00 GMT.
-		/// 
-		/// </summary>
-		/// <param name="dateString">the date string to be converted
-		/// </param>
-		/// <returns> the number of milliseconds since January 1, 1970, 00:00:00 GMT
-		/// </returns>
-		/// <throws>  ParseException if <c>dateString</c> is not in the  </throws>
-		/// <summary>  expected format 
-		/// </summary>
-		public static long StringToTime(System.String dateString)
-		{
-			return StringToDate(dateString).Ticks;
-		}
-		
-		/// <summary> Converts a string produced by <c>timeToString</c> or
-		/// <c>DateToString</c> back to a time, represented as a
-		/// Date object.
-		/// 
-		/// </summary>
-		/// <param name="dateString">the date string to be converted
-		/// </param>
-		/// <returns> the parsed time as a Date object 
-		/// </returns>
-		/// <throws>  ParseException if <c>dateString</c> is not in the  </throws>
-		/// <summary>  expected format 
-		/// </summary>
-		public static System.DateTime StringToDate(System.String dateString)
-		{
+            }
+            
+            throw new System.ArgumentException("unknown resolution " + resolution);
+        }
+        
+        /// <summary> Converts a string produced by <c>timeToString</c> or
+        /// <c>DateToString</c> back to a time, represented as the
+        /// number of milliseconds since January 1, 1970, 00:00:00 GMT.
+        /// 
+        /// </summary>
+        /// <param name="dateString">the date string to be converted
+        /// </param>
+        /// <returns> the number of milliseconds since January 1, 1970, 00:00:00 GMT
+        /// </returns>
+        /// <throws>  ParseException if <c>dateString</c> is not in the  </throws>
+        /// <summary>  expected format 
+        /// </summary>
+        public static long StringToTime(System.String dateString)
+        {
+            return StringToDate(dateString).Ticks;
+        }
+        
+        /// <summary> Converts a string produced by <c>timeToString</c> or
+        /// <c>DateToString</c> back to a time, represented as a
+        /// Date object.
+        /// 
+        /// </summary>
+        /// <param name="dateString">the date string to be converted
+        /// </param>
+        /// <returns> the parsed time as a Date object 
+        /// </returns>
+        /// <throws>  ParseException if <c>dateString</c> is not in the  </throws>
+        /// <summary>  expected format 
+        /// </summary>
+        public static System.DateTime StringToDate(System.String dateString)
+        {
             System.DateTime date;
             if (dateString.Length == 4)
             {
@@ -217,42 +217,42 @@ namespace Lucene.Net.Documents
                 throw new System.FormatException("Input is not valid date string: " + dateString);
             }
             return date;
-		}
+        }
 
-	    /// <summary> Limit a date's resolution. For example, the date <c>2004-09-21 13:50:11</c>
-	    /// will be changed to <c>2004-09-01 00:00:00</c> when using
-	    /// <c>Resolution.MONTH</c>. 
-	    /// 
-	    /// </summary>
-	    /// <param name="date"></param>
-	    /// <param name="resolution">The desired resolution of the date to be returned
-	    /// </param>
-	    /// <returns> the date with all values more precise than <c>resolution</c>
-	    /// set to 0 or 1
-	    /// </returns>
-	    public static System.DateTime Round(System.DateTime date, Resolution resolution)
-		{
-			return new System.DateTime(Round(date.Ticks / TimeSpan.TicksPerMillisecond, resolution));
-		}
-		
-		/// <summary> Limit a date's resolution. For example, the date <c>1095767411000</c>
-		/// (which represents 2004-09-21 13:50:11) will be changed to 
-		/// <c>1093989600000</c> (2004-09-01 00:00:00) when using
-		/// <c>Resolution.MONTH</c>.
-		/// 
-		/// </summary>
-		/// <param name="time">The time in milliseconds (not ticks).</param>
-		/// <param name="resolution">The desired resolution of the date to be returned
-		/// </param>
-		/// <returns> the date with all values more precise than <c>resolution</c>
-		/// set to 0 or 1, expressed as milliseconds since January 1, 1970, 00:00:00 GMT
-		/// </returns>
-		public static long Round(long time, Resolution resolution)
-		{
-			System.DateTime dt = new System.DateTime(time * TimeSpan.TicksPerMillisecond);
-			
-			if (resolution == Resolution.YEAR)
-			{
+        /// <summary> Limit a date's resolution. For example, the date <c>2004-09-21 13:50:11</c>
+        /// will be changed to <c>2004-09-01 00:00:00</c> when using
+        /// <c>Resolution.MONTH</c>. 
+        /// 
+        /// </summary>
+        /// <param name="date"></param>
+        /// <param name="resolution">The desired resolution of the date to be returned
+        /// </param>
+        /// <returns> the date with all values more precise than <c>resolution</c>
+        /// set to 0 or 1
+        /// </returns>
+        public static System.DateTime Round(System.DateTime date, Resolution resolution)
+        {
+            return new System.DateTime(Round(date.Ticks / TimeSpan.TicksPerMillisecond, resolution));
+        }
+        
+        /// <summary> Limit a date's resolution. For example, the date <c>1095767411000</c>
+        /// (which represents 2004-09-21 13:50:11) will be changed to 
+        /// <c>1093989600000</c> (2004-09-01 00:00:00) when using
+        /// <c>Resolution.MONTH</c>.
+        /// 
+        /// </summary>
+        /// <param name="time">The time in milliseconds (not ticks).</param>
+        /// <param name="resolution">The desired resolution of the date to be returned
+        /// </param>
+        /// <returns> the date with all values more precise than <c>resolution</c>
+        /// set to 0 or 1, expressed as milliseconds since January 1, 1970, 00:00:00 GMT
+        /// </returns>
+        public static long Round(long time, Resolution resolution)
+        {
+            System.DateTime dt = new System.DateTime(time * TimeSpan.TicksPerMillisecond);
+            
+            if (resolution == Resolution.YEAR)
+            {
                 dt = dt.AddMonths(1 - dt.Month);
                 dt = dt.AddDays(1 - dt.Day);
                 dt = dt.AddHours(0 - dt.Hour);
@@ -260,91 +260,91 @@ namespace Lucene.Net.Documents
                 dt = dt.AddSeconds(0 - dt.Second);
                 dt = dt.AddMilliseconds(0 - dt.Millisecond);
             }
-			else if (resolution == Resolution.MONTH)
-			{
+            else if (resolution == Resolution.MONTH)
+            {
                 dt = dt.AddDays(1 - dt.Day);
                 dt = dt.AddHours(0 - dt.Hour);
                 dt = dt.AddMinutes(0 - dt.Minute);
                 dt = dt.AddSeconds(0 - dt.Second);
                 dt = dt.AddMilliseconds(0 - dt.Millisecond);
             }
-			else if (resolution == Resolution.DAY)
-			{
+            else if (resolution == Resolution.DAY)
+            {
                 dt = dt.AddHours(0 - dt.Hour);
                 dt = dt.AddMinutes(0 - dt.Minute);
                 dt = dt.AddSeconds(0 - dt.Second);
                 dt = dt.AddMilliseconds(0 - dt.Millisecond);
             }
-			else if (resolution == Resolution.HOUR)
-			{
+            else if (resolution == Resolution.HOUR)
+            {
                 dt = dt.AddMinutes(0 - dt.Minute);
                 dt = dt.AddSeconds(0 - dt.Second);
                 dt = dt.AddMilliseconds(0 - dt.Millisecond);
             }
-			else if (resolution == Resolution.MINUTE)
-			{
+            else if (resolution == Resolution.MINUTE)
+            {
                 dt = dt.AddSeconds(0 - dt.Second);
                 dt = dt.AddMilliseconds(0 - dt.Millisecond);
             }
-			else if (resolution == Resolution.SECOND)
-			{
+            else if (resolution == Resolution.SECOND)
+            {
                 dt = dt.AddMilliseconds(0 - dt.Millisecond);
             }
-			else if (resolution == Resolution.MILLISECOND)
-			{
-				// don't cut off anything
-			}
-			else
-			{
-				throw new System.ArgumentException("unknown resolution " + resolution);
-			}
-			return dt.Ticks;
-		}
-		
-		/// <summary>Specifies the time granularity. </summary>
-		public class Resolution
-		{
-			
-			public static readonly Resolution YEAR = new Resolution("year");
-			public static readonly Resolution MONTH = new Resolution("month");
-			public static readonly Resolution DAY = new Resolution("day");
-			public static readonly Resolution HOUR = new Resolution("hour");
-			public static readonly Resolution MINUTE = new Resolution("minute");
-			public static readonly Resolution SECOND = new Resolution("second");
-			public static readonly Resolution MILLISECOND = new Resolution("millisecond");
-			
-			private System.String resolution;
-			
-			internal Resolution()
-			{
-			}
-			
-			internal Resolution(System.String resolution)
-			{
-				this.resolution = resolution;
-			}
-			
-			public override System.String ToString()
-			{
-				return resolution;
-			}
-		}
-		static DateTools()
-		{
-			{
-				// times need to be normalized so the value doesn't depend on the 
-				// location the index is created/used:
+            else if (resolution == Resolution.MILLISECOND)
+            {
+                // don't cut off anything
+            }
+            else
+            {
+                throw new System.ArgumentException("unknown resolution " + resolution);
+            }
+            return dt.Ticks;
+        }
+        
+        /// <summary>Specifies the time granularity. </summary>
+        public class Resolution
+        {
+            
+            public static readonly Resolution YEAR = new Resolution("year");
+            public static readonly Resolution MONTH = new Resolution("month");
+            public static readonly Resolution DAY = new Resolution("day");
+            public static readonly Resolution HOUR = new Resolution("hour");
+            public static readonly Resolution MINUTE = new Resolution("minute");
+            public static readonly Resolution SECOND = new Resolution("second");
+            public static readonly Resolution MILLISECOND = new Resolution("millisecond");
+            
+            private System.String resolution;
+            
+            internal Resolution()
+            {
+            }
+            
+            internal Resolution(System.String resolution)
+            {
+                this.resolution = resolution;
+            }
+            
+            public override System.String ToString()
+            {
+                return resolution;
+            }
+        }
+        static DateTools()
+        {
+            {
+                // times need to be normalized so the value doesn't depend on the 
+                // location the index is created/used:
                 // {{Aroush-2.1}}
                 /*
-				YEAR_FORMAT.setTimeZone(GMT);
-				MONTH_FORMAT.setTimeZone(GMT);
-				DAY_FORMAT.setTimeZone(GMT);
-				HOUR_FORMAT.setTimeZone(GMT);
-				MINUTE_FORMAT.setTimeZone(GMT);
-				SECOND_FORMAT.setTimeZone(GMT);
-				MILLISECOND_FORMAT.setTimeZone(GMT);
+                YEAR_FORMAT.setTimeZone(GMT);
+                MONTH_FORMAT.setTimeZone(GMT);
+                DAY_FORMAT.setTimeZone(GMT);
+                HOUR_FORMAT.setTimeZone(GMT);
+                MINUTE_FORMAT.setTimeZone(GMT);
+                SECOND_FORMAT.setTimeZone(GMT);
+                MILLISECOND_FORMAT.setTimeZone(GMT);
                 */
-			}
-		}
-	}
+            }
+        }
+    }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/core/Document/Document.cs
----------------------------------------------------------------------
diff --git a/src/core/Document/Document.cs b/src/core/Document/Document.cs
index f24a46a..e002485 100644
--- a/src/core/Document/Document.cs
+++ b/src/core/Document/Document.cs
@@ -24,149 +24,149 @@ using Searcher = Lucene.Net.Search.Searcher;
 
 namespace Lucene.Net.Documents
 {
-	
-	/// <summary>Documents are the unit of indexing and search.
-	/// 
-	/// A Document is a set of fields.  Each field has a name and a textual value.
-	/// A field may be <see cref="IFieldable.IsStored()">stored</see> with the document, in which
-	/// case it is returned with search hits on the document.  Thus each document
-	/// should typically contain one or more stored fields which uniquely identify
-	/// it.
-	/// 
-	/// <p/>Note that fields which are <i>not</i> <see cref="IFieldable.IsStored()">stored</see> are
-	/// <i>not</i> available in documents retrieved from the index, e.g. with <see cref="ScoreDoc.Doc" />,
-	/// <see cref="Searcher.Doc(int)" /> or <see cref="IndexReader.Document(int)" />.
-	/// </summary>
-	
-	[Serializable]
-	public sealed class Document
-	{
-		private class AnonymousClassEnumeration : System.Collections.IEnumerator
-		{
-			public AnonymousClassEnumeration(Document enclosingInstance)
-			{
-				InitBlock(enclosingInstance);
-			}
-			private void  InitBlock(Document enclosingInstance)
-			{
-				this.enclosingInstance = enclosingInstance;
-				iter = Enclosing_Instance.fields.GetEnumerator();
-			}
-			private System.Object tempAuxObj;
-			public bool MoveNext()
-			{
-				bool result = HasMoreElements();
-				if (result)
-				{
-					tempAuxObj = NextElement();
-				}
-				return result;
-			}
-			public void  Reset()
-			{
-				tempAuxObj = null;
-			}
-			public System.Object Current
-			{
-				get
-				{
-					return tempAuxObj;
-				}
-				
-			}
-			private Document enclosingInstance;
-			public Document Enclosing_Instance
-			{
-				get
-				{
-					return enclosingInstance;
-				}
-				
-			}
-			internal System.Collections.IEnumerator iter;
-			public bool HasMoreElements()
-			{
-				return iter.MoveNext();
-			}
-			public System.Object NextElement()
-			{
-				return iter.Current;
-			}
-		}
-		internal System.Collections.Generic.IList<IFieldable> fields = new System.Collections.Generic.List<IFieldable>();
-		private float boost = 1.0f;
-		
-		/// <summary>Constructs a new document with no fields. </summary>
-		public Document()
-		{
-		}
+    
+    /// <summary>Documents are the unit of indexing and search.
+    /// 
+    /// A Document is a set of fields.  Each field has a name and a textual value.
+    /// A field may be <see cref="IFieldable.IsStored()">stored</see> with the document, in which
+    /// case it is returned with search hits on the document.  Thus each document
+    /// should typically contain one or more stored fields which uniquely identify
+    /// it.
+    /// 
+    /// <p/>Note that fields which are <i>not</i> <see cref="IFieldable.IsStored()">stored</see> are
+    /// <i>not</i> available in documents retrieved from the index, e.g. with <see cref="ScoreDoc.Doc" />,
+    /// <see cref="Searcher.Doc(int)" /> or <see cref="IndexReader.Document(int)" />.
+    /// </summary>
+    
+    [Serializable]
+    public sealed class Document
+    {
+        private class AnonymousClassEnumeration : System.Collections.IEnumerator
+        {
+            public AnonymousClassEnumeration(Document enclosingInstance)
+            {
+                InitBlock(enclosingInstance);
+            }
+            private void  InitBlock(Document enclosingInstance)
+            {
+                this.enclosingInstance = enclosingInstance;
+                iter = Enclosing_Instance.fields.GetEnumerator();
+            }
+            private System.Object tempAuxObj;
+            public bool MoveNext()
+            {
+                bool result = HasMoreElements();
+                if (result)
+                {
+                    tempAuxObj = NextElement();
+                }
+                return result;
+            }
+            public void  Reset()
+            {
+                tempAuxObj = null;
+            }
+            public System.Object Current
+            {
+                get
+                {
+                    return tempAuxObj;
+                }
+                
+            }
+            private Document enclosingInstance;
+            public Document Enclosing_Instance
+            {
+                get
+                {
+                    return enclosingInstance;
+                }
+                
+            }
+            internal System.Collections.IEnumerator iter;
+            public bool HasMoreElements()
+            {
+                return iter.MoveNext();
+            }
+            public System.Object NextElement()
+            {
+                return iter.Current;
+            }
+        }
+        internal System.Collections.Generic.IList<IFieldable> fields = new System.Collections.Generic.List<IFieldable>();
+        private float boost = 1.0f;
+        
+        /// <summary>Constructs a new document with no fields. </summary>
+        public Document()
+        {
+        }
 
 
-	    /// <summary>Gets or sets, at indexing time, the boost factor. 
-	    /// <para>
-	    /// The default is 1.0
-	    /// </para>
-	    /// <p/>Note that once a document is indexed this value is no longer available
-	    /// from the index.  At search time, for retrieved documents, this method always 
-	    /// returns 1. This however does not mean that the boost value set at  indexing 
-	    /// time was ignored - it was just combined with other indexing time factors and 
-	    /// stored elsewhere, for better indexing and search performance. (For more 
-	    /// information see the "norm(t,d)" part of the scoring formula in 
-	    /// <see cref="Lucene.Net.Search.Similarity">Similarity</see>.)
-	    /// </summary>
-	    public float Boost
-	    {
-	        get { return boost; }
-	        set { this.boost = value; }
-	    }
+        /// <summary>Gets or sets, at indexing time, the boost factor. 
+        /// <para>
+        /// The default is 1.0
+        /// </para>
+        /// <p/>Note that once a document is indexed this value is no longer available
+        /// from the index.  At search time, for retrieved documents, this method always 
+        /// returns 1. This however does not mean that the boost value set at  indexing 
+        /// time was ignored - it was just combined with other indexing time factors and 
+        /// stored elsewhere, for better indexing and search performance. (For more 
+        /// information see the "norm(t,d)" part of the scoring formula in 
+        /// <see cref="Lucene.Net.Search.Similarity">Similarity</see>.)
+        /// </summary>
+        public float Boost
+        {
+            get { return boost; }
+            set { this.boost = value; }
+        }
 
-	    /// <summary> <p/>Adds a field to a document.  Several fields may be added with
-		/// the same name.  In this case, if the fields are indexed, their text is
-		/// treated as though appended for the purposes of search.<p/>
-		/// <p/> Note that add like the removeField(s) methods only makes sense 
-		/// prior to adding a document to an index. These methods cannot
-		/// be used to change the content of an existing index! In order to achieve this,
-		/// a document has to be deleted from an index and a new changed version of that
-		/// document has to be added.<p/>
-		/// </summary>
-		public void  Add(IFieldable field)
-		{
-			fields.Add(field);
-		}
-		
-		/// <summary> <p/>Removes field with the specified name from the document.
-		/// If multiple fields exist with this name, this method removes the first field that has been added.
-		/// If there is no field with the specified name, the document remains unchanged.<p/>
-		/// <p/> Note that the removeField(s) methods like the add method only make sense 
-		/// prior to adding a document to an index. These methods cannot
-		/// be used to change the content of an existing index! In order to achieve this,
-		/// a document has to be deleted from an index and a new changed version of that
-		/// document has to be added.<p/>
-		/// </summary>
-		public void  RemoveField(System.String name)
-		{
-			System.Collections.Generic.IEnumerator<IFieldable> it = fields.GetEnumerator();
-			while (it.MoveNext())
-			{
-				IFieldable field = it.Current;
-				if (field.Name.Equals(name))
-				{
+        /// <summary> <p/>Adds a field to a document.  Several fields may be added with
+        /// the same name.  In this case, if the fields are indexed, their text is
+        /// treated as though appended for the purposes of search.<p/>
+        /// <p/> Note that add like the removeField(s) methods only makes sense 
+        /// prior to adding a document to an index. These methods cannot
+        /// be used to change the content of an existing index! In order to achieve this,
+        /// a document has to be deleted from an index and a new changed version of that
+        /// document has to be added.<p/>
+        /// </summary>
+        public void  Add(IFieldable field)
+        {
+            fields.Add(field);
+        }
+        
+        /// <summary> <p/>Removes field with the specified name from the document.
+        /// If multiple fields exist with this name, this method removes the first field that has been added.
+        /// If there is no field with the specified name, the document remains unchanged.<p/>
+        /// <p/> Note that the removeField(s) methods like the add method only make sense 
+        /// prior to adding a document to an index. These methods cannot
+        /// be used to change the content of an existing index! In order to achieve this,
+        /// a document has to be deleted from an index and a new changed version of that
+        /// document has to be added.<p/>
+        /// </summary>
+        public void  RemoveField(System.String name)
+        {
+            System.Collections.Generic.IEnumerator<IFieldable> it = fields.GetEnumerator();
+            while (it.MoveNext())
+            {
+                IFieldable field = it.Current;
+                if (field.Name.Equals(name))
+                {
                     fields.Remove(field);
-					return ;
-				}
-			}
-		}
-		
-		/// <summary> <p/>Removes all fields with the given name from the document.
-		/// If there is no field with the specified name, the document remains unchanged.<p/>
-		/// <p/> Note that the removeField(s) methods like the add method only make sense 
-		/// prior to adding a document to an index. These methods cannot
-		/// be used to change the content of an existing index! In order to achieve this,
-		/// a document has to be deleted from an index and a new changed version of that
-		/// document has to be added.<p/>
-		/// </summary>
-		public void  RemoveFields(System.String name)
-		{
+                    return ;
+                }
+            }
+        }
+        
+        /// <summary> <p/>Removes all fields with the given name from the document.
+        /// If there is no field with the specified name, the document remains unchanged.<p/>
+        /// <p/> Note that the removeField(s) methods like the add method only make sense 
+        /// prior to adding a document to an index. These methods cannot
+        /// be used to change the content of an existing index! In order to achieve this,
+        /// a document has to be deleted from an index and a new changed version of that
+        /// document has to be added.<p/>
+        /// </summary>
+        public void  RemoveFields(System.String name)
+        {
             for (int i = fields.Count - 1; i >= 0; i--)
             {
                 IFieldable field = fields[i];
@@ -175,208 +175,208 @@ namespace Lucene.Net.Documents
                     fields.RemoveAt(i);
                 }
             }
-		}
-		
-		/// <summary>Returns a field with the given name if any exist in this document, or
-		/// null.  If multiple fields exists with this name, this method returns the
-		/// first value added.
-		/// Do not use this method with lazy loaded fields.
-		/// </summary>
-		public Field GetField(System.String name)
-		{
-		    return (Field) GetFieldable(name);
-		}
-		
-		
-		/// <summary>Returns a field with the given name if any exist in this document, or
-		/// null.  If multiple fields exists with this name, this method returns the
-		/// first value added.
-		/// </summary>
-		public IFieldable GetFieldable(System.String name)
-		{
-			foreach(IFieldable field in fields)
+        }
+        
+        /// <summary>Returns a field with the given name if any exist in this document, or
+        /// null.  If multiple fields exists with this name, this method returns the
+        /// first value added.
+        /// Do not use this method with lazy loaded fields.
+        /// </summary>
+        public Field GetField(System.String name)
+        {
+            return (Field) GetFieldable(name);
+        }
+        
+        
+        /// <summary>Returns a field with the given name if any exist in this document, or
+        /// null.  If multiple fields exists with this name, this method returns the
+        /// first value added.
+        /// </summary>
+        public IFieldable GetFieldable(System.String name)
+        {
+            foreach(IFieldable field in fields)
+            {
+                if (field.Name.Equals(name))
+                    return field;
+            }
+            return null;
+        }
+        
+        /// <summary>Returns the string value of the field with the given name if any exist in
+        /// this document, or null.  If multiple fields exist with this name, this
+        /// method returns the first value added. If only binary fields with this name
+        /// exist, returns null.
+        /// </summary>
+        public System.String Get(System.String name)
+        {
+            foreach(IFieldable field in fields)
+            {
+                if (field.Name.Equals(name) && (!field.IsBinary))
+                    return field.StringValue;
+            }
+            return null;
+        }
+        
+        /// <summary>Returns a List of all the fields in a document.
+        /// <p/>Note that fields which are <i>not</i> <see cref="IFieldable.IsStored()">stored</see> are
+        /// <i>not</i> available in documents retrieved from the
+        /// index, e.g. <see cref="Searcher.Doc(int)" /> or <see cref="IndexReader.Document(int)" />.
+        /// </summary>
+        public System.Collections.Generic.IList<IFieldable> GetFields()
+        {
+            return fields;
+        }
+        
+        private static readonly Field[] NO_FIELDS = new Field[0];
+        
+        /// <summary> Returns an array of <see cref="Field" />s with the given name.
+        /// Do not use with lazy loaded fields.
+        /// This method returns an empty array when there are no
+        /// matching fields.  It never returns null.
+        /// 
+        /// </summary>
+        /// <param name="name">the name of the field
+        /// </param>
+        /// <returns> a <c>Field[]</c> array
+        /// </returns>
+        public Field[] GetFields(System.String name)
+        {
+            var result = new System.Collections.Generic.List<Field>();
+            foreach(IFieldable field in fields)
+            {
+                if (field.Name.Equals(name))
+                {
+                    result.Add((Field)field);
+                }
+            }
+            
+            if (result.Count == 0)
+                return NO_FIELDS;
+            
+            return result.ToArray();
+        }
+        
+        
+        private static readonly IFieldable[] NO_FIELDABLES = new IFieldable[0];
+        
+        /// <summary> Returns an array of <see cref="IFieldable" />s with the given name.
+        /// This method returns an empty array when there are no
+        /// matching fields.  It never returns null.
+        /// 
+        /// </summary>
+        /// <param name="name">the name of the field
+        /// </param>
+        /// <returns> a <c>Fieldable[]</c> array
+        /// </returns>
+        public IFieldable[] GetFieldables(System.String name)
+        {
+            var result = new System.Collections.Generic.List<IFieldable>();
+            foreach(IFieldable field in fields)
+            {
+                if (field.Name.Equals(name))
+                {
+                    result.Add(field);
+                }
+            }
+            
+            if (result.Count == 0)
+                return NO_FIELDABLES;
+            
+            return result.ToArray();
+        }
+        
+        
+        private static readonly System.String[] NO_STRINGS = new System.String[0];
+        
+        /// <summary> Returns an array of values of the field specified as the method parameter.
+        /// This method returns an empty array when there are no
+        /// matching fields.  It never returns null.
+        /// </summary>
+        /// <param name="name">the name of the field
+        /// </param>
+        /// <returns> a <c>String[]</c> of field values
+        /// </returns>
+        public System.String[] GetValues(System.String name)
+        {
+            var result = new System.Collections.Generic.List<string>();
+            foreach(IFieldable field in fields)
+            {
+                if (field.Name.Equals(name) && (!field.IsBinary))
+                    result.Add(field.StringValue);
+            }
+            
+            if (result.Count == 0)
+                return NO_STRINGS;
+            
+            return result.ToArray();
+        }
+        
+        private static readonly byte[][] NO_BYTES = new byte[0][];
+        
+        /// <summary> Returns an array of byte arrays for of the fields that have the name specified
+        /// as the method parameter.  This method returns an empty
+        /// array when there are no matching fields.  It never
+        /// returns null.
+        /// 
+        /// </summary>
+        /// <param name="name">the name of the field
+        /// </param>
+        /// <returns> a <c>byte[][]</c> of binary field values
+        /// </returns>
+        public byte[][] GetBinaryValues(System.String name)
+        {
+            var result = new System.Collections.Generic.List<byte[]>();
+            foreach(IFieldable field in fields)
             {
-				if (field.Name.Equals(name))
-					return field;
-			}
-			return null;
-		}
-		
-		/// <summary>Returns the string value of the field with the given name if any exist in
-		/// this document, or null.  If multiple fields exist with this name, this
-		/// method returns the first value added. If only binary fields with this name
-		/// exist, returns null.
-		/// </summary>
-		public System.String Get(System.String name)
-		{
-			foreach(IFieldable field in fields)
-			{
-				if (field.Name.Equals(name) && (!field.IsBinary))
-					return field.StringValue;
-			}
-			return null;
-		}
-		
-		/// <summary>Returns a List of all the fields in a document.
-		/// <p/>Note that fields which are <i>not</i> <see cref="IFieldable.IsStored()">stored</see> are
-		/// <i>not</i> available in documents retrieved from the
-		/// index, e.g. <see cref="Searcher.Doc(int)" /> or <see cref="IndexReader.Document(int)" />.
-		/// </summary>
-		public System.Collections.Generic.IList<IFieldable> GetFields()
-		{
-			return fields;
-		}
-		
-		private static readonly Field[] NO_FIELDS = new Field[0];
-		
-		/// <summary> Returns an array of <see cref="Field" />s with the given name.
-		/// Do not use with lazy loaded fields.
-		/// This method returns an empty array when there are no
-		/// matching fields.  It never returns null.
-		/// 
-		/// </summary>
-		/// <param name="name">the name of the field
-		/// </param>
-		/// <returns> a <c>Field[]</c> array
-		/// </returns>
-		public Field[] GetFields(System.String name)
-		{
-			var result = new System.Collections.Generic.List<Field>();
-			foreach(IFieldable field in fields)
-			{
-				if (field.Name.Equals(name))
-				{
-					result.Add((Field)field);
-				}
-			}
-			
-			if (result.Count == 0)
-				return NO_FIELDS;
-			
-			return result.ToArray();
-		}
-		
-		
-		private static readonly IFieldable[] NO_FIELDABLES = new IFieldable[0];
-		
-		/// <summary> Returns an array of <see cref="IFieldable" />s with the given name.
-		/// This method returns an empty array when there are no
-		/// matching fields.  It never returns null.
-		/// 
-		/// </summary>
-		/// <param name="name">the name of the field
-		/// </param>
-		/// <returns> a <c>Fieldable[]</c> array
-		/// </returns>
-		public IFieldable[] GetFieldables(System.String name)
-		{
-			var result = new System.Collections.Generic.List<IFieldable>();
-			foreach(IFieldable field in fields)
-			{
-				if (field.Name.Equals(name))
-				{
-					result.Add(field);
-				}
-			}
-			
-			if (result.Count == 0)
-				return NO_FIELDABLES;
-			
-			return result.ToArray();
-		}
-		
-		
-		private static readonly System.String[] NO_STRINGS = new System.String[0];
-		
-		/// <summary> Returns an array of values of the field specified as the method parameter.
-		/// This method returns an empty array when there are no
-		/// matching fields.  It never returns null.
-		/// </summary>
-		/// <param name="name">the name of the field
-		/// </param>
-		/// <returns> a <c>String[]</c> of field values
-		/// </returns>
-		public System.String[] GetValues(System.String name)
-		{
-			var result = new System.Collections.Generic.List<string>();
-			foreach(IFieldable field in fields)
-			{
-				if (field.Name.Equals(name) && (!field.IsBinary))
-					result.Add(field.StringValue);
-			}
-			
-			if (result.Count == 0)
-				return NO_STRINGS;
-			
-			return result.ToArray();
-		}
-		
-		private static readonly byte[][] NO_BYTES = new byte[0][];
-		
-		/// <summary> Returns an array of byte arrays for of the fields that have the name specified
-		/// as the method parameter.  This method returns an empty
-		/// array when there are no matching fields.  It never
-		/// returns null.
-		/// 
-		/// </summary>
-		/// <param name="name">the name of the field
-		/// </param>
-		/// <returns> a <c>byte[][]</c> of binary field values
-		/// </returns>
-		public byte[][] GetBinaryValues(System.String name)
-		{
-			var result = new System.Collections.Generic.List<byte[]>();
-			foreach(IFieldable field in fields)
-			{
-				if (field.Name.Equals(name) && (field.IsBinary))
-					result.Add(field.GetBinaryValue());
-			}
-			
-			if (result.Count == 0)
-				return NO_BYTES;
+                if (field.Name.Equals(name) && (field.IsBinary))
+                    result.Add(field.GetBinaryValue());
+            }
+            
+            if (result.Count == 0)
+                return NO_BYTES;
 
             return result.ToArray();
         }
-		
-		/// <summary> Returns an array of bytes for the first (or only) field that has the name
-		/// specified as the method parameter. This method will return <c>null</c>
-		/// if no binary fields with the specified name are available.
-		/// There may be non-binary fields with the same name.
-		/// 
-		/// </summary>
-		/// <param name="name">the name of the field.
-		/// </param>
-		/// <returns> a <c>byte[]</c> containing the binary field value or <c>null</c>
-		/// </returns>
-		public byte[] GetBinaryValue(System.String name)
-		{
-			foreach(IFieldable field in fields)
-			{
-				if (field.Name.Equals(name) && (field.IsBinary))
-					return field.GetBinaryValue();
-			}
-			return null;
-		}
-		
-		/// <summary>Prints the fields of a document for human consumption. </summary>
-		public override System.String ToString()
-		{
-			System.Text.StringBuilder buffer = new System.Text.StringBuilder();
-			buffer.Append("Document<");
-			for (int i = 0; i < fields.Count; i++)
-			{
-				IFieldable field = fields[i];
-				buffer.Append(field.ToString());
-				if (i != fields.Count - 1)
-					buffer.Append(" ");
-			}
-			buffer.Append(">");
-			return buffer.ToString();
-		}
+        
+        /// <summary> Returns an array of bytes for the first (or only) field that has the name
+        /// specified as the method parameter. This method will return <c>null</c>
+        /// if no binary fields with the specified name are available.
+        /// There may be non-binary fields with the same name.
+        /// 
+        /// </summary>
+        /// <param name="name">the name of the field.
+        /// </param>
+        /// <returns> a <c>byte[]</c> containing the binary field value or <c>null</c>
+        /// </returns>
+        public byte[] GetBinaryValue(System.String name)
+        {
+            foreach(IFieldable field in fields)
+            {
+                if (field.Name.Equals(name) && (field.IsBinary))
+                    return field.GetBinaryValue();
+            }
+            return null;
+        }
+        
+        /// <summary>Prints the fields of a document for human consumption. </summary>
+        public override System.String ToString()
+        {
+            System.Text.StringBuilder buffer = new System.Text.StringBuilder();
+            buffer.Append("Document<");
+            for (int i = 0; i < fields.Count; i++)
+            {
+                IFieldable field = fields[i];
+                buffer.Append(field.ToString());
+                if (i != fields.Count - 1)
+                    buffer.Append(" ");
+            }
+            buffer.Append(">");
+            return buffer.ToString();
+        }
 
         public System.Collections.Generic.IList<IFieldable> fields_ForNUnit
         {
             get { return fields; }
         }
-	}
+    }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/core/Document/FieldSelector.cs
----------------------------------------------------------------------
diff --git a/src/core/Document/FieldSelector.cs b/src/core/Document/FieldSelector.cs
index f940f08..18d2e1c 100644
--- a/src/core/Document/FieldSelector.cs
+++ b/src/core/Document/FieldSelector.cs
@@ -21,17 +21,17 @@ namespace Lucene.Net.Documents
 {
     /// <summary> Similar to a <a href="http://download.oracle.com/javase/1.5.0/docs/api/java/io/FileFilter.html">
     /// java.io.FileFilter</a>, the FieldSelector allows one to make decisions about
-	/// what Fields get loaded on a <see cref="Document" /> by <see cref="Lucene.Net.Index.IndexReader.Document(int,Lucene.Net.Documents.FieldSelector)" />
-	/// </summary>
-	public interface FieldSelector
-	{
-		
-		/// <summary> </summary>
-		/// <param name="fieldName">the field to accept or reject
-		/// </param>
-		/// <returns> an instance of <see cref="FieldSelectorResult" />
-		/// if the <see cref="Field" /> named <c>fieldName</c> should be loaded.
-		/// </returns>
-		FieldSelectorResult Accept(System.String fieldName);
-	}
+    /// what Fields get loaded on a <see cref="Document" /> by <see cref="Lucene.Net.Index.IndexReader.Document(int,Lucene.Net.Documents.FieldSelector)" />
+    /// </summary>
+    public interface FieldSelector
+    {
+        
+        /// <summary> </summary>
+        /// <param name="fieldName">the field to accept or reject
+        /// </param>
+        /// <returns> an instance of <see cref="FieldSelectorResult" />
+        /// if the <see cref="Field" /> named <c>fieldName</c> should be loaded.
+        /// </returns>
+        FieldSelectorResult Accept(System.String fieldName);
+    }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/core/Document/FieldSelectorResult.cs
----------------------------------------------------------------------
diff --git a/src/core/Document/FieldSelectorResult.cs b/src/core/Document/FieldSelectorResult.cs
index 7d3a889..15c8606 100644
--- a/src/core/Document/FieldSelectorResult.cs
+++ b/src/core/Document/FieldSelectorResult.cs
@@ -21,7 +21,7 @@ using System.Runtime.InteropServices;
 
 namespace Lucene.Net.Documents
 {
-	/// <summary>Provides information about what should be done with this Field</summary>
+    /// <summary>Provides information about what should be done with this Field</summary>
     public enum FieldSelectorResult
     {
         /// <summary>


Mime
View raw message