lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ccurr...@apache.org
Subject [49/51] [partial] Mass convert mixed tabs to spaces
Date Wed, 03 Apr 2013 17:40:32 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/contrib/DistributedSearch/Distributed/Configuration/CurrentIndex.cs
----------------------------------------------------------------------
diff --git a/src/contrib/DistributedSearch/Distributed/Configuration/CurrentIndex.cs b/src/contrib/DistributedSearch/Distributed/Configuration/CurrentIndex.cs
index eee771d..325207e 100644
--- a/src/contrib/DistributedSearch/Distributed/Configuration/CurrentIndex.cs
+++ b/src/contrib/DistributedSearch/Distributed/Configuration/CurrentIndex.cs
@@ -31,12 +31,12 @@ using Lucene.Net.Distributed;
 
 namespace Lucene.Net.Distributed.Configuration
 {
-	public enum IndexSetting
-	{
-		NoSetting	= 0,
-		IndexA		= 1,
-		IndexB		= 2
-	}
+    public enum IndexSetting
+    {
+        NoSetting    = 0,
+        IndexA        = 1,
+        IndexB        = 2
+    }
 
     /// <summary>
     /// Definition of current index information managed by the 
@@ -61,280 +61,280 @@ namespace Lucene.Net.Distributed.Configuration
     /// </code>
     /// </summary>
     public class CurrentIndex
-	{
-		#region Variables
-		private static readonly string CURRENTINDEX = "currentIndex";
-		private static readonly string INDEX_A = "indexA";
-		private static readonly string INDEX_B = "indexB";
-		private static readonly string TOGGLE = "toggle";
-		private string _strLocalPath;
-		private string _strStatusDir;
-		private string _strIndexAPath;
-		private string _strIndexBPath;
-		private bool _bIndexChanged=false;
+    {
+        #region Variables
+        private static readonly string CURRENTINDEX = "currentIndex";
+        private static readonly string INDEX_A = "indexA";
+        private static readonly string INDEX_B = "indexB";
+        private static readonly string TOGGLE = "toggle";
+        private string _strLocalPath;
+        private string _strStatusDir;
+        private string _strIndexAPath;
+        private string _strIndexBPath;
+        private bool _bIndexChanged=false;
 
         private int _mergeFactor = (ConfigurationManager.AppSettings["IndexMergeFactor"] != null ? Convert.ToInt32(ConfigurationManager.AppSettings["IndexMergeFactor"]) : 5);
         private int _maxMergeDocs = (ConfigurationManager.AppSettings["IndexMaxMergeDocs"] != null ? Convert.ToInt32(ConfigurationManager.AppSettings["IndexMaxMergeDocs"]) : 9999999);
 
-		#endregion
-
-		#region Constructors
-		/// <summary>
-		/// Constructs a new CurrentIndex using the XmlNode value (from IndexSetConfigurationHandler configuration)
-		/// </summary>
-		/// <param name="node">XmlNode containing configuration information</param>
-		/// <param name="strLocalPath">Local filesystem path to source index</param>
-		public CurrentIndex(XmlNode node, string strLocalPath)
-		{
-			this._strLocalPath=strLocalPath;
-			this.LoadValues(node);
-		}
-
-		/// <summary>
-		/// Constructs a shell CurrentIndex. Use this constructor to interact 
-		/// with the underlying status and toggle files ONLY.
-		/// </summary>
-		/// <param name="sStatusDir">Filesystem path to the status and toggle files for an index</param>
-		public CurrentIndex(string sStatusDir)
-		{
-			this._strStatusDir=sStatusDir;
-		}
-		#endregion
-
-		#region Internals
+        #endregion
+
+        #region Constructors
+        /// <summary>
+        /// Constructs a new CurrentIndex using the XmlNode value (from IndexSetConfigurationHandler configuration)
+        /// </summary>
+        /// <param name="node">XmlNode containing configuration information</param>
+        /// <param name="strLocalPath">Local filesystem path to source index</param>
+        public CurrentIndex(XmlNode node, string strLocalPath)
+        {
+            this._strLocalPath=strLocalPath;
+            this.LoadValues(node);
+        }
+
+        /// <summary>
+        /// Constructs a shell CurrentIndex. Use this constructor to interact 
+        /// with the underlying status and toggle files ONLY.
+        /// </summary>
+        /// <param name="sStatusDir">Filesystem path to the status and toggle files for an index</param>
+        public CurrentIndex(string sStatusDir)
+        {
+            this._strStatusDir=sStatusDir;
+        }
+        #endregion
+
+        #region Internals
         /// <summary>
         /// Internal routine for use by constructor that accepts a configuration
         /// entry structured as XmlNode.
         /// </summary>
         /// <param name="node">XmlNode containing configuration information</param>
-		internal void LoadValues(XmlNode node)
-		{
-			foreach (XmlNode c in node.ChildNodes)
-			{
-				if (c.Name.ToLower()=="targetpath")
-				{
-					this._strIndexAPath = c.Attributes["indexA"].Value;
-					this._strIndexBPath = c.Attributes["indexB"].Value;
-				}
-				else if (c.Name.ToLower()=="statusdir")
-				{
-					this._strStatusDir = c.Attributes["value"].Value;
-				}
-			}
+        internal void LoadValues(XmlNode node)
+        {
+            foreach (XmlNode c in node.ChildNodes)
+            {
+                if (c.Name.ToLower()=="targetpath")
+                {
+                    this._strIndexAPath = c.Attributes["indexA"].Value;
+                    this._strIndexBPath = c.Attributes["indexB"].Value;
+                }
+                else if (c.Name.ToLower()=="statusdir")
+                {
+                    this._strStatusDir = c.Attributes["value"].Value;
+                }
+            }
             this.CheckValidConfiguration(node);
-		}
-		#endregion
-
-		#region Public properties
-		/// <summary>
-		/// Filesystem path to the local source for an index; this is the path to the master index.
-		/// </summary>
-		public string LocalPath
-		{
-			get {return this._strLocalPath;}
-		}
-		/// <summary>
-		/// Filesystem path to a LuceneServer's status and toggle file for a given IndexSet
-		/// </summary>
-		public string StatusDirectory
-		{
-			get {return this._strStatusDir;}
-		}
-
-		/// <summary>
-		/// Indicates the current index directory (IndexSetting enum) in use (the online set)
-		/// </summary>
-		public IndexSetting IndexSetting
-		{
-			get
-			{
-				string input=(this.GetCurrentIndex());
-				return (input==CurrentIndex.INDEX_A ? IndexSetting.IndexA : (input==CurrentIndex.INDEX_B ? IndexSetting.IndexB : IndexSetting.IndexA));
-			}
-		}
-
-		/// <summary>
-		/// Indicates the index directory to be used in any index searcher refresh
-		/// by determining if any updates have been applied
-		/// </summary>
-		public IndexSetting IndexSettingRefresh
-		{
-			get
-			{
-				if (this.HasChanged)
-				{
-					return (this.IndexSetting==IndexSetting.IndexA ? IndexSetting.IndexB : (this.IndexSetting==IndexSetting.IndexB ? IndexSetting.IndexA : IndexSetting.IndexB ));
-				}
-				else
-				{
-					return this.IndexSetting;
-				}
-			}
-		}
-
-		/// <summary>
-		/// Indicates if the current index permits updated indexes to be copied to CopyTargetPath
-		/// </summary>
-		public bool CanCopy
-		{
-			get {return (!this.GetToggle() && (this.LocalIndexVersion!=this.TargetIndexVersion));}
-		}
-
-		/// <summary>
-		/// Indicates if the current index has pending updates (in the offline directory) to be used by an index searcher
+        }
+        #endregion
+
+        #region Public properties
+        /// <summary>
+        /// Filesystem path to the local source for an index; this is the path to the master index.
+        /// </summary>
+        public string LocalPath
+        {
+            get {return this._strLocalPath;}
+        }
+        /// <summary>
+        /// Filesystem path to a LuceneServer's status and toggle file for a given IndexSet
+        /// </summary>
+        public string StatusDirectory
+        {
+            get {return this._strStatusDir;}
+        }
+
+        /// <summary>
+        /// Indicates the current index directory (IndexSetting enum) in use (the online set)
+        /// </summary>
+        public IndexSetting IndexSetting
+        {
+            get
+            {
+                string input=(this.GetCurrentIndex());
+                return (input==CurrentIndex.INDEX_A ? IndexSetting.IndexA : (input==CurrentIndex.INDEX_B ? IndexSetting.IndexB : IndexSetting.IndexA));
+            }
+        }
+
+        /// <summary>
+        /// Indicates the index directory to be used in any index searcher refresh
+        /// by determining if any updates have been applied
+        /// </summary>
+        public IndexSetting IndexSettingRefresh
+        {
+            get
+            {
+                if (this.HasChanged)
+                {
+                    return (this.IndexSetting==IndexSetting.IndexA ? IndexSetting.IndexB : (this.IndexSetting==IndexSetting.IndexB ? IndexSetting.IndexA : IndexSetting.IndexB ));
+                }
+                else
+                {
+                    return this.IndexSetting;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Indicates if the current index permits updated indexes to be copied to CopyTargetPath
+        /// </summary>
+        public bool CanCopy
+        {
+            get {return (!this.GetToggle() && (this.LocalIndexVersion!=this.TargetIndexVersion));}
+        }
+
+        /// <summary>
+        /// Indicates if the current index has pending updates (in the offline directory) to be used by an index searcher
         /// in a refresh evaluation
-		/// </summary>
-		public bool HasChanged
-		{
-			get {return this.GetToggle();}
-		}
-
-		/// <summary>
-		/// The target directory path to be used when updating the offline index
-		/// </summary>
-		public string CopyTargetPath
-		{
-			get {return (this.IndexSetting==IndexSetting.IndexA ? this._strIndexBPath : (this.IndexSetting==IndexSetting.IndexB ? this._strIndexAPath : ""));}
-		}
-		#endregion
-
-		#region Public methods
-		/// <summary>
-		/// Method that executes a filesystem copy of all directory files from a local path to 
+        /// </summary>
+        public bool HasChanged
+        {
+            get {return this.GetToggle();}
+        }
+
+        /// <summary>
+        /// The target directory path to be used when updating the offline index
+        /// </summary>
+        public string CopyTargetPath
+        {
+            get {return (this.IndexSetting==IndexSetting.IndexA ? this._strIndexBPath : (this.IndexSetting==IndexSetting.IndexB ? this._strIndexAPath : ""));}
+        }
+        #endregion
+
+        #region Public methods
+        /// <summary>
+        /// Method that executes a filesystem copy of all directory files from a local path to 
         /// the proper offline index.  This method ensures no conflicts occur with the online index.
-		/// </summary>
-		/// <returns>bool</returns>
-		public bool Copy()
-		{
-			try
-			{
-				if (this.CanCopy && this.CopyTargetPath!="")
-				{
-					this.DeleteDirectoryFiles(this.CopyTargetPath);
-					this.CopyDirectory(this._strLocalPath, this.CopyTargetPath);
-					return true;
-				}
-				else
-				{
-					return false;
-				}
-			}
-			catch (Exception e)
-			{
+        /// </summary>
+        /// <returns>bool</returns>
+        public bool Copy()
+        {
+            try
+            {
+                if (this.CanCopy && this.CopyTargetPath!="")
+                {
+                    this.DeleteDirectoryFiles(this.CopyTargetPath);
+                    this.CopyDirectory(this._strLocalPath, this.CopyTargetPath);
+                    return true;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            catch (Exception e)
+            {
                 //Do something with e
-				return false;
-			}
-		}
+                return false;
+            }
+        }
 
         /// <summary>
         /// Method that executes a filesystem copy of updated or new files from a local path to 
         /// the proper offline index.  This method ensures no conflicts occur with the online index.
         /// </summary>
         /// <returns></returns>
-		public bool CopyIncremental()
-		{
-			try
-			{
-				if (this.CanCopy && this.CopyTargetPath!="")
-				{
-					this.CopyDirectoryIncremental(this._strLocalPath, this.CopyTargetPath);
-					return true;
-				}
-				else
-				{
-					return false;
-				}
-			}
-			catch (Exception e)
-			{
+        public bool CopyIncremental()
+        {
+            try
+            {
+                if (this.CanCopy && this.CopyTargetPath!="")
+                {
+                    this.CopyDirectoryIncremental(this._strLocalPath, this.CopyTargetPath);
+                    return true;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            catch (Exception e)
+            {
                 //Do something with e
                 return false;
-			}
-		}
-
-		/// <summary>
-		/// Takes a name/value pair collection to be used in updating an index. 
-		/// Deletes are necessary to ensure no duplication occurs within the index.
-		/// </summary>
-		/// <param name="nvcDeleteCollection">Set of record IDs (with underlying field name) to be applied for index updating</param>
-		public void ProcessLocalIndexDeletes(NameValueCollection nvcDeleteCollection)
-		{
-			if (IndexReader.IndexExists(this._strLocalPath) && nvcDeleteCollection.Count>0)
-			{
-				IndexReader idxDeleter = IndexReader.Open(this._strLocalPath);
-				string[] arKeys = nvcDeleteCollection.AllKeys;
-				int xDelete=0;
-				for (int k=0;k<arKeys.Length;k++)
-				{
-					string[] arKeyValues=nvcDeleteCollection.GetValues(arKeys[k]);
-					for (int v=0;v<arKeyValues.Length;v++)
-						xDelete=idxDeleter.DeleteDocuments(new Term(arKeys[k].ToString(),arKeyValues[v].ToString()));
-				}
-				idxDeleter.Close();
-			}
-		}
-
-		/// <summary>
-		/// Executes a loop on the Documents arraylist, adding each one to the index with the associated analyzer.
-		/// </summary>
-		/// <param name="oAnalyzer">Analyzer to be used in index document addition</param>
-		/// <param name="alAddDocuments">Arraylist of Lucene Document objects to be inserted in the index</param>
-		/// <param name="bCompoundFile">Setting to dictate if the index should use compound format</param>
-		public void ProcessLocalIndexAdditions(Analyzer oAnalyzer, Hashtable htAddDocuments, bool bCompoundFile)
-		{
-			IndexWriter idxWriter = this.GetIndexWriter(this._strLocalPath, oAnalyzer, bCompoundFile);
+            }
+        }
+
+        /// <summary>
+        /// Takes a name/value pair collection to be used in updating an index. 
+        /// Deletes are necessary to ensure no duplication occurs within the index.
+        /// </summary>
+        /// <param name="nvcDeleteCollection">Set of record IDs (with underlying field name) to be applied for index updating</param>
+        public void ProcessLocalIndexDeletes(NameValueCollection nvcDeleteCollection)
+        {
+            if (IndexReader.IndexExists(this._strLocalPath) && nvcDeleteCollection.Count>0)
+            {
+                IndexReader idxDeleter = IndexReader.Open(this._strLocalPath);
+                string[] arKeys = nvcDeleteCollection.AllKeys;
+                int xDelete=0;
+                for (int k=0;k<arKeys.Length;k++)
+                {
+                    string[] arKeyValues=nvcDeleteCollection.GetValues(arKeys[k]);
+                    for (int v=0;v<arKeyValues.Length;v++)
+                        xDelete=idxDeleter.DeleteDocuments(new Term(arKeys[k].ToString(),arKeyValues[v].ToString()));
+                }
+                idxDeleter.Close();
+            }
+        }
+
+        /// <summary>
+        /// Executes a loop on the Documents arraylist, adding each one to the index with the associated analyzer.
+        /// </summary>
+        /// <param name="oAnalyzer">Analyzer to be used in index document addition</param>
+        /// <param name="alAddDocuments">Arraylist of Lucene Document objects to be inserted in the index</param>
+        /// <param name="bCompoundFile">Setting to dictate if the index should use compound format</param>
+        public void ProcessLocalIndexAdditions(Analyzer oAnalyzer, Hashtable htAddDocuments, bool bCompoundFile)
+        {
+            IndexWriter idxWriter = this.GetIndexWriter(this._strLocalPath, oAnalyzer, bCompoundFile);
             idxWriter.SetMergeFactor(5);
             idxWriter.SetMaxMergeDocs(9999999);
 
-			foreach (DictionaryEntry de in htAddDocuments)
-			{
-				Document d = (Document)de.Key;
-				Analyzer a = (Analyzer)de.Value;
-				idxWriter.AddDocument(d,a);
-			}
-			idxWriter.Close();
-		}
-
-		/// <summary>
-		/// Single method to be used by a searchhost to indicate an index refresh has completed.
-		/// </summary>
-		public void IndexRefresh()
-		{
-			if (this.HasChanged)
-			{
-				this.SetCurrentIndex(this.IndexSettingRefresh);
-				this.SetToggle(false);
-			}
-		}
-
-		/// <summary>
-		/// Single method to be used by an index updater to indicate an index update has completed.
-		/// </summary>
-		public void UpdateRefresh()
-		{
-			this.SetToggle(true);
-		}
-		#endregion
-
-		#region Private properties
-		/// <summary>
-		/// The filesystem path to the underlying index status file
-		/// </summary>
-		private string CurrentIndexFile
-		{
-			get {return (this._strStatusDir+(this._strStatusDir.EndsWith(@"\") ? "" : @"\")+CURRENTINDEX);}
-		}
-		/// <summary>
-		/// The filesystem path to the underlying index toggle file
-		/// </summary>
-		private string ToggleFile
-		{
-			get {return (this._strStatusDir+(this._strStatusDir.EndsWith(@"\") ? "" : @"\")+TOGGLE);}
-		}
-
-		#endregion
-
-		#region Private methods
+            foreach (DictionaryEntry de in htAddDocuments)
+            {
+                Document d = (Document)de.Key;
+                Analyzer a = (Analyzer)de.Value;
+                idxWriter.AddDocument(d,a);
+            }
+            idxWriter.Close();
+        }
+
+        /// <summary>
+        /// Single method to be used by a searchhost to indicate an index refresh has completed.
+        /// </summary>
+        public void IndexRefresh()
+        {
+            if (this.HasChanged)
+            {
+                this.SetCurrentIndex(this.IndexSettingRefresh);
+                this.SetToggle(false);
+            }
+        }
+
+        /// <summary>
+        /// Single method to be used by an index updater to indicate an index update has completed.
+        /// </summary>
+        public void UpdateRefresh()
+        {
+            this.SetToggle(true);
+        }
+        #endregion
+
+        #region Private properties
+        /// <summary>
+        /// The filesystem path to the underlying index status file
+        /// </summary>
+        private string CurrentIndexFile
+        {
+            get {return (this._strStatusDir+(this._strStatusDir.EndsWith(@"\") ? "" : @"\")+CURRENTINDEX);}
+        }
+        /// <summary>
+        /// The filesystem path to the underlying index toggle file
+        /// </summary>
+        private string ToggleFile
+        {
+            get {return (this._strStatusDir+(this._strStatusDir.EndsWith(@"\") ? "" : @"\")+TOGGLE);}
+        }
+
+        #endregion
+
+        #region Private methods
 
         /// <summary>
         /// Validation routine to ensure all required values were present within xml configuration node
@@ -349,222 +349,222 @@ namespace Lucene.Net.Distributed.Configuration
             if (this._strIndexBPath == null) throw new ConfigurationErrorsException("CurrentIndex indexB invalid: " + Environment.NewLine + node.OuterXml);
         }
 
-		/// <summary>
-		/// Returns the current toggle file setting
-		/// </summary>
-		/// <returns>bool</returns>
-		private bool GetToggle()
-		{
-			bool bValue=false;
-			string input="";
-			try
-			{
-				if (!File.Exists(this.ToggleFile))
-				{
-					this.SetToggle(false);
-				}
-				else
-				{
-					StreamReader sr = File.OpenText(this.ToggleFile);
-					input = sr.ReadLine();
-					sr.Close();
-					bValue = (input.ToLower()=="true" ? true : false);
-				}
-			}
-			catch (Exception ex)
-			{
-				//Do something with ex
-			}
-			return bValue;
-		}
-
-		/// <summary>
-		/// Returns the current status file setting
-		/// </summary>
-		/// <returns>string</returns>
-		private string GetCurrentIndex()
-		{
-			string input="";
-			try
-			{
-				if (!File.Exists(this.CurrentIndexFile))
-				{
-					this.SetCurrentIndex(IndexSetting.IndexA);
-					input=IndexSetting.IndexA.ToString();
-				}
-				else
-				{
-					StreamReader sr = File.OpenText(this.CurrentIndexFile);
-					input = sr.ReadLine();
-					sr.Close();
-				}
-			}
-			catch (Exception ex)
-			{
-				//Do something with ex
-			}
-			return input;
-		}
-
-		/// <summary>
-		/// Updates the status file with the IndexSetting value parameter
-		/// </summary>
-		/// <param name="eIndexSetting">Setting to be applied to the status file</param>
-		private void SetCurrentIndex(IndexSetting eIndexSetting)
-		{
-			try
-			{
-				StreamWriter sw = File.CreateText(this.CurrentIndexFile);
-				sw.WriteLine((eIndexSetting==IndexSetting.IndexA ? CurrentIndex.INDEX_A : CurrentIndex.INDEX_B));
-				sw.Close();
-			}
-			catch (Exception ex)
-			{
-				//Do something with ex
-			}
-		}
-
-		/// <summary>
-		/// IndexWriter that can be used to apply updates to an index
-		/// </summary>
-		/// <param name="indexPath">File system path to the target index</param>
-		/// <param name="oAnalyzer">Lucene Analyzer to be used by the underlying IndexWriter</param>
-		/// <param name="bCompoundFile">Setting to dictate if the index should use compound format</param>
-		/// <returns></returns>
-		private IndexWriter GetIndexWriter(string indexPath, Analyzer oAnalyzer, bool bCompoundFile)
-		{
-			bool bExists = System.IO.Directory.Exists(indexPath);
-			if (bExists==false)
-				System.IO.Directory.CreateDirectory(indexPath);
-			bExists=IndexReader.IndexExists(FSDirectory.GetDirectory(indexPath, false));
-			IndexWriter idxWriter = new IndexWriter(indexPath, oAnalyzer, !bExists);
-			idxWriter.SetUseCompoundFile(bCompoundFile);
-			return idxWriter;
-		}
-
-		/// <summary>
-		/// Updates the toggle file with the bool value parameter
-		/// </summary>
-		/// <param name="bValue">Bool to be applied to the toggle file</param>
-		private void SetToggle(bool bValue)
-		{
-			try
-			{
-				StreamWriter sw = File.CreateText(this.ToggleFile);
-				sw.WriteLine(bValue.ToString());
-				sw.Close();
-				this._bIndexChanged=bValue;
-			}
-			catch (Exception ex)
-			{
-				//Do something with ex
-			}
-		}
-
-		/// <summary>
-		/// Returns the numeric index version (using Lucene objects) for the index located at LocalPath
-		/// </summary>
-		private long LocalIndexVersion
-		{
-			get {return IndexReader.GetCurrentVersion(this.LocalPath);}
-		}
-		/// <summary>
-		/// Returns the numeric index version (using Lucene objects) for the index located at CopyTargetPath
-		/// </summary>
-		private long TargetIndexVersion
-		{
-			get {return (IndexReader.IndexExists(this.CopyTargetPath) ? IndexReader.GetCurrentVersion(this.CopyTargetPath) : 0);}
-		}
-
-		/// <summary>
-		/// Deletes index files at the filesystem directoryPath location
-		/// </summary>
-		/// <param name="directoryPath">Filesystem path</param>
-		private void DeleteDirectoryFiles(string directoryPath)
-		{
-			try
-			{
-				if(!System.IO.Directory.Exists(directoryPath))
-					return;
-				DirectoryInfo di = new DirectoryInfo(directoryPath);
-				FileInfo[] arFi = di.GetFiles();
-				foreach(FileInfo fi in arFi)
-					fi.Delete();
-			}
-			catch(Exception e)
-			{
-				//Do something with e
-			}
-		}
-
-		/// <summary>
-		/// Copy all index files from the sourceDirPath to the destDirPath
-		/// </summary>
-		/// <param name="sourceDirPath">Filesystem path</param>
-		/// <param name="destDirPath">Filesystem path</param>
-		private void CopyDirectory(string sourceDirPath, string destDirPath)
-		{
-			string[] Files;
-
-			if(destDirPath[destDirPath.Length-1]!=Path.DirectorySeparatorChar) 
-				destDirPath+=Path.DirectorySeparatorChar;
-			if(!System.IO.Directory.Exists(destDirPath)) System.IO.Directory.CreateDirectory(destDirPath);
-			Files=System.IO.Directory.GetFileSystemEntries(sourceDirPath);
-			foreach(string Element in Files)
-			{
-				// Sub directories
-				if(System.IO.Directory.Exists(Element)) 
-					CopyDirectory(Element,destDirPath+Path.GetFileName(Element));
-					// Files in directory
-				else 
-					File.Copy(Element,destDirPath+Path.GetFileName(Element),true);
-			}
-
-		}
+        /// <summary>
+        /// Returns the current toggle file setting
+        /// </summary>
+        /// <returns>bool</returns>
+        private bool GetToggle()
+        {
+            bool bValue=false;
+            string input="";
+            try
+            {
+                if (!File.Exists(this.ToggleFile))
+                {
+                    this.SetToggle(false);
+                }
+                else
+                {
+                    StreamReader sr = File.OpenText(this.ToggleFile);
+                    input = sr.ReadLine();
+                    sr.Close();
+                    bValue = (input.ToLower()=="true" ? true : false);
+                }
+            }
+            catch (Exception ex)
+            {
+                //Do something with ex
+            }
+            return bValue;
+        }
+
+        /// <summary>
+        /// Returns the current status file setting
+        /// </summary>
+        /// <returns>string</returns>
+        private string GetCurrentIndex()
+        {
+            string input="";
+            try
+            {
+                if (!File.Exists(this.CurrentIndexFile))
+                {
+                    this.SetCurrentIndex(IndexSetting.IndexA);
+                    input=IndexSetting.IndexA.ToString();
+                }
+                else
+                {
+                    StreamReader sr = File.OpenText(this.CurrentIndexFile);
+                    input = sr.ReadLine();
+                    sr.Close();
+                }
+            }
+            catch (Exception ex)
+            {
+                //Do something with ex
+            }
+            return input;
+        }
+
+        /// <summary>
+        /// Updates the status file with the IndexSetting value parameter
+        /// </summary>
+        /// <param name="eIndexSetting">Setting to be applied to the status file</param>
+        private void SetCurrentIndex(IndexSetting eIndexSetting)
+        {
+            try
+            {
+                StreamWriter sw = File.CreateText(this.CurrentIndexFile);
+                sw.WriteLine((eIndexSetting==IndexSetting.IndexA ? CurrentIndex.INDEX_A : CurrentIndex.INDEX_B));
+                sw.Close();
+            }
+            catch (Exception ex)
+            {
+                //Do something with ex
+            }
+        }
+
+        /// <summary>
+        /// IndexWriter that can be used to apply updates to an index
+        /// </summary>
+        /// <param name="indexPath">File system path to the target index</param>
+        /// <param name="oAnalyzer">Lucene Analyzer to be used by the underlying IndexWriter</param>
+        /// <param name="bCompoundFile">Setting to dictate if the index should use compound format</param>
+        /// <returns></returns>
+        private IndexWriter GetIndexWriter(string indexPath, Analyzer oAnalyzer, bool bCompoundFile)
+        {
+            bool bExists = System.IO.Directory.Exists(indexPath);
+            if (bExists==false)
+                System.IO.Directory.CreateDirectory(indexPath);
+            bExists=IndexReader.IndexExists(FSDirectory.GetDirectory(indexPath, false));
+            IndexWriter idxWriter = new IndexWriter(indexPath, oAnalyzer, !bExists);
+            idxWriter.SetUseCompoundFile(bCompoundFile);
+            return idxWriter;
+        }
+
+        /// <summary>
+        /// Updates the toggle file with the bool value parameter
+        /// </summary>
+        /// <param name="bValue">Bool to be applied to the toggle file</param>
+        private void SetToggle(bool bValue)
+        {
+            try
+            {
+                StreamWriter sw = File.CreateText(this.ToggleFile);
+                sw.WriteLine(bValue.ToString());
+                sw.Close();
+                this._bIndexChanged=bValue;
+            }
+            catch (Exception ex)
+            {
+                //Do something with ex
+            }
+        }
+
+        /// <summary>
+        /// Returns the numeric index version (using Lucene objects) for the index located at LocalPath
+        /// </summary>
+        private long LocalIndexVersion
+        {
+            get {return IndexReader.GetCurrentVersion(this.LocalPath);}
+        }
+        /// <summary>
+        /// Returns the numeric index version (using Lucene objects) for the index located at CopyTargetPath
+        /// </summary>
+        private long TargetIndexVersion
+        {
+            get {return (IndexReader.IndexExists(this.CopyTargetPath) ? IndexReader.GetCurrentVersion(this.CopyTargetPath) : 0);}
+        }
+
+        /// <summary>
+        /// Deletes index files at the filesystem directoryPath location
+        /// </summary>
+        /// <param name="directoryPath">Filesystem path</param>
+        private void DeleteDirectoryFiles(string directoryPath)
+        {
+            try
+            {
+                if(!System.IO.Directory.Exists(directoryPath))
+                    return;
+                DirectoryInfo di = new DirectoryInfo(directoryPath);
+                FileInfo[] arFi = di.GetFiles();
+                foreach(FileInfo fi in arFi)
+                    fi.Delete();
+            }
+            catch(Exception e)
+            {
+                //Do something with e
+            }
+        }
+
+        /// <summary>
+        /// Copy all index files from the sourceDirPath to the destDirPath
+        /// </summary>
+        /// <param name="sourceDirPath">Filesystem path</param>
+        /// <param name="destDirPath">Filesystem path</param>
+        private void CopyDirectory(string sourceDirPath, string destDirPath)
+        {
+            string[] Files;
+
+            if(destDirPath[destDirPath.Length-1]!=Path.DirectorySeparatorChar) 
+                destDirPath+=Path.DirectorySeparatorChar;
+            if(!System.IO.Directory.Exists(destDirPath)) System.IO.Directory.CreateDirectory(destDirPath);
+            Files=System.IO.Directory.GetFileSystemEntries(sourceDirPath);
+            foreach(string Element in Files)
+            {
+                // Sub directories
+                if(System.IO.Directory.Exists(Element)) 
+                    CopyDirectory(Element,destDirPath+Path.GetFileName(Element));
+                    // Files in directory
+                else 
+                    File.Copy(Element,destDirPath+Path.GetFileName(Element),true);
+            }
+
+        }
 
         /// <summary>
         /// Copy only new and updated index files from the sourceDirPath to the destDirPath
         /// </summary>
         /// <param name="sourceDirPath">Filesystem path</param>
         /// <param name="destDirPath">Filesystem path</param>
-		private void CopyDirectoryIncremental(string sourceDirPath, string destDirPath)
-		{
-			string[] Files;
-
-			if(destDirPath[destDirPath.Length-1]!=Path.DirectorySeparatorChar) 
-				destDirPath+=Path.DirectorySeparatorChar;
-			Files=System.IO.Directory.GetFileSystemEntries(sourceDirPath);
-			if(!System.IO.Directory.Exists(destDirPath))
-			{
-				System.IO.Directory.CreateDirectory(destDirPath);
-				foreach(string Element in Files)
-				{
-					// Sub directories
-					if(System.IO.Directory.Exists(Element)) 
-						CopyDirectory(Element,destDirPath+Path.GetFileName(Element));
-						// Files in directory
-					else 
-						File.Copy(Element,destDirPath+Path.GetFileName(Element),true);
-				}
-			}
-			else
-			{
-				foreach(string Element in Files)
-				{
-					if(System.IO.Directory.Exists(Element))
-					{
-						CopyDirectoryIncremental(Element,destDirPath+Path.GetFileName(Element));
-					}
-					else
-					{
-						if (System.IO.File.Exists(destDirPath+Path.GetFileName(Element)))
-							this.CopyFileIncremental(Element, destDirPath+Path.GetFileName(Element));
-						else
-							File.Copy(Element,destDirPath+Path.GetFileName(Element),true);
-					}
-				}
-			}
-		}
+        private void CopyDirectoryIncremental(string sourceDirPath, string destDirPath)
+        {
+            string[] Files;
+
+            if(destDirPath[destDirPath.Length-1]!=Path.DirectorySeparatorChar) 
+                destDirPath+=Path.DirectorySeparatorChar;
+            Files=System.IO.Directory.GetFileSystemEntries(sourceDirPath);
+            if(!System.IO.Directory.Exists(destDirPath))
+            {
+                System.IO.Directory.CreateDirectory(destDirPath);
+                foreach(string Element in Files)
+                {
+                    // Sub directories
+                    if(System.IO.Directory.Exists(Element)) 
+                        CopyDirectory(Element,destDirPath+Path.GetFileName(Element));
+                        // Files in directory
+                    else 
+                        File.Copy(Element,destDirPath+Path.GetFileName(Element),true);
+                }
+            }
+            else
+            {
+                foreach(string Element in Files)
+                {
+                    if(System.IO.Directory.Exists(Element))
+                    {
+                        CopyDirectoryIncremental(Element,destDirPath+Path.GetFileName(Element));
+                    }
+                    else
+                    {
+                        if (System.IO.File.Exists(destDirPath+Path.GetFileName(Element)))
+                            this.CopyFileIncremental(Element, destDirPath+Path.GetFileName(Element));
+                        else
+                            File.Copy(Element,destDirPath+Path.GetFileName(Element),true);
+                    }
+                }
+            }
+        }
 
         /// <summary>
         /// Evaluates the LastWriteTime and Length properties of two files to determine
@@ -573,13 +573,13 @@ namespace Lucene.Net.Distributed.Configuration
         /// <param name="filepath1">Filesystem path</param>
         /// <param name="filepath2">Filesystem path</param>
         private void CopyFileIncremental(string filepath1, string filepath2)
-		{
-			FileInfo fi1 = new FileInfo(filepath1);
-			FileInfo fi2 = new FileInfo(filepath2);
-			if ((fi1.LastWriteTime!=fi2.LastWriteTime)||(fi1.Length!=fi2.Length))
-				File.Copy(filepath1,filepath2,true);
-		}
-		#endregion
+        {
+            FileInfo fi1 = new FileInfo(filepath1);
+            FileInfo fi2 = new FileInfo(filepath2);
+            if ((fi1.LastWriteTime!=fi2.LastWriteTime)||(fi1.Length!=fi2.Length))
+                File.Copy(filepath1,filepath2,true);
+        }
+        #endregion
 
         #region Static methods
         /// <summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/contrib/DistributedSearch/Distributed/Configuration/DistributedSearcher.cs
----------------------------------------------------------------------
diff --git a/src/contrib/DistributedSearch/Distributed/Configuration/DistributedSearcher.cs b/src/contrib/DistributedSearch/Distributed/Configuration/DistributedSearcher.cs
index 500b606..13f0d35 100644
--- a/src/contrib/DistributedSearch/Distributed/Configuration/DistributedSearcher.cs
+++ b/src/contrib/DistributedSearch/Distributed/Configuration/DistributedSearcher.cs
@@ -24,7 +24,7 @@ using Lucene.Net.Distributed;
 
 namespace Lucene.Net.Distributed.Configuration
 {
-	/// <summary>
+    /// <summary>
     /// Definition of a configurable set of search indexes made accessible by the 
     /// LuceneServer windows service for a consuming application. These search indexes 
     /// are defined in the configuration file of an application. The locations defined 
@@ -40,18 +40,18 @@ namespace Lucene.Net.Distributed.Configuration
     /// </code>
     /// </summary>
     public class DistributedSearcher
-	{
+    {
         private int _id;
-		private SearchMethod _eSearchMethod;
-		private string _strLocation;
+        private SearchMethod _eSearchMethod;
+        private string _strLocation;
 
         /// <summary>
         /// Public constructor for DistributedSearcher. A DistributedSearcher is defined
         /// in XML configuration and is loaded via a custom configuration handler.
         /// </summary>
         /// <param name="xSection">The Xml definition in the configuration file</param>
-		public DistributedSearcher(XmlNode xSection)
-		{
+        public DistributedSearcher(XmlNode xSection)
+        {
             
             XmlAttributeCollection attributeCollection = xSection.Attributes;
             if (attributeCollection == null)
@@ -95,7 +95,7 @@ namespace Lucene.Net.Distributed.Configuration
                 //exec ping check if needed
             }
 
-		}
+        }
 
         /// <summary>
         /// Unique Id value assigned to this DistributedSearcher. Not required for any processing,
@@ -109,18 +109,18 @@ namespace Lucene.Net.Distributed.Configuration
         /// <summary>
         /// Enumeration value specifying the locality of the index -- local or remote
         /// </summary>
-		public SearchMethod SearchMethod
-		{
-			get {return this._eSearchMethod;}
-		}
+        public SearchMethod SearchMethod
+        {
+            get {return this._eSearchMethod;}
+        }
         /// <summary>
         /// Reference path to the DistributedSearcher. If SearchMethod is Local, this is a local
         /// file-system path, i.e. "c:\local\index". If SearchMethod is Distributed, this is the 
         /// URI of the server-activated service type, i.e. "tcp://192.168.1.100:1089/RemoteIndex".
         /// </summary>
-		public string Location
-		{
-			get {return this._strLocation;}
-		}
-	}
+        public string Location
+        {
+            get {return this._strLocation;}
+        }
+    }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/contrib/DistributedSearch/Distributed/Configuration/DistributedSearcherConfigurationHandler.cs
----------------------------------------------------------------------
diff --git a/src/contrib/DistributedSearch/Distributed/Configuration/DistributedSearcherConfigurationHandler.cs b/src/contrib/DistributedSearch/Distributed/Configuration/DistributedSearcherConfigurationHandler.cs
index 49adbd3..5816a8f 100644
--- a/src/contrib/DistributedSearch/Distributed/Configuration/DistributedSearcherConfigurationHandler.cs
+++ b/src/contrib/DistributedSearch/Distributed/Configuration/DistributedSearcherConfigurationHandler.cs
@@ -28,15 +28,15 @@ namespace Lucene.Net.Distributed.Configuration
     /// by the LuceneServer windows service.
     /// </summary>
     public class DistributedSearcherConfigurationHandler : IConfigurationSectionHandler
-	{
+    {
         /// <summary>
         /// Empty public constructor for the configuration handler.
         /// </summary>
-		public DistributedSearcherConfigurationHandler()
-		{
-		}
+        public DistributedSearcherConfigurationHandler()
+        {
+        }
 
-		#region IConfigurationSectionHandler Members
+        #region IConfigurationSectionHandler Members
 
         /// <summary>
         /// Required implementation of IConfigurationSectionHandler.
@@ -45,12 +45,12 @@ namespace Lucene.Net.Distributed.Configuration
         /// <param name="configContext">Configuration context object</param>
         /// <param name="section">Xml configuration in the application configuration file</param>
         /// <returns></returns>
-		public object Create(object parent, object configContext, XmlNode section)
-		{
-			DistributedSearchers wsConfig = new DistributedSearchers(section);
-			return wsConfig;
-		}
+        public object Create(object parent, object configContext, XmlNode section)
+        {
+            DistributedSearchers wsConfig = new DistributedSearchers(section);
+            return wsConfig;
+        }
 
-		#endregion
-	}
+        #endregion
+    }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/contrib/DistributedSearch/Distributed/Configuration/DistributedSearchers.cs
----------------------------------------------------------------------
diff --git a/src/contrib/DistributedSearch/Distributed/Configuration/DistributedSearchers.cs b/src/contrib/DistributedSearch/Distributed/Configuration/DistributedSearchers.cs
index 5bdaff2..28aa1f2 100644
--- a/src/contrib/DistributedSearch/Distributed/Configuration/DistributedSearchers.cs
+++ b/src/contrib/DistributedSearch/Distributed/Configuration/DistributedSearchers.cs
@@ -37,16 +37,16 @@ namespace Lucene.Net.Distributed.Configuration
     /// </code>
     /// </summary>
     public class DistributedSearchers
-	{
-		private DistributedSearcher[] _arDistributedSearcherArray;
+    {
+        private DistributedSearcher[] _arDistributedSearcherArray;
 
         /// <summary>
         /// Accessor method for the configurable DistributedSearchers.
         /// </summary>
-		public static DistributedSearchers GetConfig
-		{
+        public static DistributedSearchers GetConfig
+        {
             get { return (DistributedSearchers)ConfigurationManager.GetSection("DistributedSearchers"); }
-		}
+        }
 
         /// <summary>
         /// Public constructor for DistributedSearchers. A DistributedSearcher is defined
@@ -54,29 +54,29 @@ namespace Lucene.Net.Distributed.Configuration
         /// </summary>
         /// <param name="xSection">The Xml definition in the configuration file</param>
         public DistributedSearchers(XmlNode xSection)
-		{
-			this._arDistributedSearcherArray = new DistributedSearcher[xSection.ChildNodes.Count];
-			int x=0;
+        {
+            this._arDistributedSearcherArray = new DistributedSearcher[xSection.ChildNodes.Count];
+            int x=0;
 
-			foreach (XmlNode c in xSection.ChildNodes)
-			{
-				if (c.Name.ToLower()=="DistributedSearcher")
-				{
-					DistributedSearcher ws = new DistributedSearcher(c);
-					this._arDistributedSearcherArray[x] = ws;
-					x++;
-				}
-			}
-		}
+            foreach (XmlNode c in xSection.ChildNodes)
+            {
+                if (c.Name.ToLower()=="DistributedSearcher")
+                {
+                    DistributedSearcher ws = new DistributedSearcher(c);
+                    this._arDistributedSearcherArray[x] = ws;
+                    x++;
+                }
+            }
+        }
 
         /// <summary>
         /// Strongly-typed array of DistributedSearcher objects as defined in 
         /// a configuration section.
         /// </summary>
         public DistributedSearcher[] DistributedSearcherArray
-		{
-			get {return this._arDistributedSearcherArray;}
-		}
+        {
+            get {return this._arDistributedSearcherArray;}
+        }
 
-	}
+    }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/contrib/DistributedSearch/Distributed/Configuration/LuceneServerIndex.cs
----------------------------------------------------------------------
diff --git a/src/contrib/DistributedSearch/Distributed/Configuration/LuceneServerIndex.cs b/src/contrib/DistributedSearch/Distributed/Configuration/LuceneServerIndex.cs
index caaa28f..2ec1084 100644
--- a/src/contrib/DistributedSearch/Distributed/Configuration/LuceneServerIndex.cs
+++ b/src/contrib/DistributedSearch/Distributed/Configuration/LuceneServerIndex.cs
@@ -23,7 +23,7 @@ using System.Xml;
 
 namespace Lucene.Net.Distributed.Configuration
 {
-	/// <summary>
+    /// <summary>
     /// Definition of a configurable search index made accessible by the 
     /// LuceneServer windows service.
     /// 
@@ -41,13 +41,13 @@ namespace Lucene.Net.Distributed.Configuration
     ///   </LuceneServerIndexes>
     /// </code>
     /// </summary>
-	public class LuceneServerIndex
-	{
-		private string _strObjectUri;
-		private int _intPort;
-		private DirectoryInfo[] _arIndexADirectories;
-		private DirectoryInfo[] _arIndexBDirectories;
-		private DirectoryInfo[] _arRefreshDirectories;
+    public class LuceneServerIndex
+    {
+        private string _strObjectUri;
+        private int _intPort;
+        private DirectoryInfo[] _arIndexADirectories;
+        private DirectoryInfo[] _arIndexBDirectories;
+        private DirectoryInfo[] _arRefreshDirectories;
 
         /// <summary>
         /// Public constructor for LuceneServerIndex. A LuceneServerIndex is defined
@@ -56,9 +56,9 @@ namespace Lucene.Net.Distributed.Configuration
         /// <param name="xSection">The Xml definition in the configuration file</param>
         /// <param name="defaultPort">The default Port value, as defined in the contained 
         /// LuceneServerIndexes configuration</param>
-		public LuceneServerIndex(XmlNode xSection, int defaultPort)
-		{
-			XmlAttributeCollection attributeCollection = xSection.Attributes;
+        public LuceneServerIndex(XmlNode xSection, int defaultPort)
+        {
+            XmlAttributeCollection attributeCollection = xSection.Attributes;
             try
             {
                 this._strObjectUri = attributeCollection["ObjectUri"].Value;
@@ -80,16 +80,16 @@ namespace Lucene.Net.Distributed.Configuration
             if (xSection.ChildNodes.Count == 0)
                 throw new ConfigurationErrorsException("LuceneServerIndex configuration missing: " + Environment.NewLine + xSection.OuterXml);
 
-			_arIndexADirectories = new DirectoryInfo[xSection.ChildNodes.Count];
-			_arIndexBDirectories = new DirectoryInfo[xSection.ChildNodes.Count];
-			DirectoryInfo diA;
-			DirectoryInfo diB;
-			int x=0;
+            _arIndexADirectories = new DirectoryInfo[xSection.ChildNodes.Count];
+            _arIndexBDirectories = new DirectoryInfo[xSection.ChildNodes.Count];
+            DirectoryInfo diA;
+            DirectoryInfo diB;
+            int x=0;
 
-			foreach (XmlNode c in xSection.ChildNodes)
-			{
-				if (c.Name.ToLower()=="directory")
-				{
+            foreach (XmlNode c in xSection.ChildNodes)
+            {
+                if (c.Name.ToLower()=="directory")
+                {
                     try
                     {
                         diA = new DirectoryInfo(c.Attributes["indexA"].Value);
@@ -113,10 +113,10 @@ namespace Lucene.Net.Distributed.Configuration
                     {
                         throw new ConfigurationErrorsException("LuceneServerIndex configuration Directory error: indexA=" + c.Attributes["indexB"].Value + Environment.NewLine + xSection.OuterXml);
                     }
-					x++;
-				}
-			}
-		}
+                    x++;
+                }
+            }
+        }
 
         /// <summary>
         /// The published Uri name for a collective set of indexes. The ObjectUri
@@ -126,35 +126,35 @@ namespace Lucene.Net.Distributed.Configuration
         /// <para>This value is required in configuration.</para>
         /// </summary>
         public string ObjectUri
-		{
-			get {return this._strObjectUri;}
-		}
+        {
+            get {return this._strObjectUri;}
+        }
 
         /// <summary>
         /// A definable port number for the published Uri. Use this value to override the default
         /// Port setting for all published URIs.
         /// <para>This value is optional in configuration.</para>
         /// </summary>
-		public int Port
-		{
-			get {return this._intPort;}
-		}
+        public int Port
+        {
+            get {return this._intPort;}
+        }
 
         /// <summary>
         /// File-system path to the "IndexA" location of the index files.
         /// </summary>
-		public DirectoryInfo[] IndexADirectories
-		{
-			get {return this._arIndexADirectories;}
-		}
+        public DirectoryInfo[] IndexADirectories
+        {
+            get {return this._arIndexADirectories;}
+        }
 
         /// <summary>
         /// File-system path to the "IndexB" location of the index files.
         /// </summary>
-		public DirectoryInfo[] IndexBDirectories
-		{
-			get {return this._arIndexBDirectories;}
-		}
+        public DirectoryInfo[] IndexBDirectories
+        {
+            get {return this._arIndexBDirectories;}
+        }
 
         /// <summary>
         /// Instance method that returns an array of directory paths associated
@@ -162,14 +162,14 @@ namespace Lucene.Net.Distributed.Configuration
         /// </summary>
         /// <param name="oIndexSettingRefresh">IndexSetting enumeration value</param>
         /// <returns>DirectoryInfo[] of directory paths</returns>
-		public DirectoryInfo[] RefreshDirectories(IndexSetting oIndexSettingRefresh)
-		{
-			this._arRefreshDirectories=null;
-			if (oIndexSettingRefresh==IndexSetting.IndexA)
-				this._arRefreshDirectories = this._arIndexADirectories;
-			else if (oIndexSettingRefresh==IndexSetting.IndexB)
-				this._arRefreshDirectories = this._arIndexBDirectories;
-			return this._arRefreshDirectories;
-		}
-	}
+        public DirectoryInfo[] RefreshDirectories(IndexSetting oIndexSettingRefresh)
+        {
+            this._arRefreshDirectories=null;
+            if (oIndexSettingRefresh==IndexSetting.IndexA)
+                this._arRefreshDirectories = this._arIndexADirectories;
+            else if (oIndexSettingRefresh==IndexSetting.IndexB)
+                this._arRefreshDirectories = this._arIndexBDirectories;
+            return this._arRefreshDirectories;
+        }
+    }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/contrib/DistributedSearch/Distributed/Configuration/LuceneServerIndexConfigurationHandler.cs
----------------------------------------------------------------------
diff --git a/src/contrib/DistributedSearch/Distributed/Configuration/LuceneServerIndexConfigurationHandler.cs b/src/contrib/DistributedSearch/Distributed/Configuration/LuceneServerIndexConfigurationHandler.cs
index 13362bc..9d54022 100644
--- a/src/contrib/DistributedSearch/Distributed/Configuration/LuceneServerIndexConfigurationHandler.cs
+++ b/src/contrib/DistributedSearch/Distributed/Configuration/LuceneServerIndexConfigurationHandler.cs
@@ -21,23 +21,23 @@ using System.Xml;
 
 namespace Lucene.Net.Distributed.Configuration
 {
-	/// <summary>
-	/// Implementation of custom configuration handler for the definition of search indexes
+    /// <summary>
+    /// Implementation of custom configuration handler for the definition of search indexes
     /// made accessible by the LuceneServer windows service.
-	/// </summary>
-	public class LuceneServerIndexConfigurationHandler: IConfigurationSectionHandler
-	{
+    /// </summary>
+    public class LuceneServerIndexConfigurationHandler: IConfigurationSectionHandler
+    {
         public LuceneServerIndexConfigurationHandler()
-		{
-		}
-		#region IConfigurationSectionHandler Members
+        {
+        }
+        #region IConfigurationSectionHandler Members
 
-		public object Create(object parent, object configContext, XmlNode section)
-		{
-			LuceneServerIndexes rsConfig = new LuceneServerIndexes(section);
-			return rsConfig;
-		}
+        public object Create(object parent, object configContext, XmlNode section)
+        {
+            LuceneServerIndexes rsConfig = new LuceneServerIndexes(section);
+            return rsConfig;
+        }
 
-		#endregion
-	}
+        #endregion
+    }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/contrib/DistributedSearch/Distributed/Configuration/LuceneServerIndexes.cs
----------------------------------------------------------------------
diff --git a/src/contrib/DistributedSearch/Distributed/Configuration/LuceneServerIndexes.cs b/src/contrib/DistributedSearch/Distributed/Configuration/LuceneServerIndexes.cs
index bce6d3b..19cb856 100644
--- a/src/contrib/DistributedSearch/Distributed/Configuration/LuceneServerIndexes.cs
+++ b/src/contrib/DistributedSearch/Distributed/Configuration/LuceneServerIndexes.cs
@@ -40,17 +40,17 @@ namespace Lucene.Net.Distributed.Configuration
     /// </code>
     /// </summary>
     public class LuceneServerIndexes
-	{
-		private LuceneServerIndex[] _arLuceneServerIndexArray;
-		private int _intPort;
+    {
+        private LuceneServerIndex[] _arLuceneServerIndexArray;
+        private int _intPort;
 
         /// <summary>
         /// Accessor method for the configurable search indexes.
         /// </summary>
-		public static LuceneServerIndexes GetConfig
-		{
-			get {return (LuceneServerIndexes)ConfigurationManager.GetSection("LuceneServerIndexes");}
-		}
+        public static LuceneServerIndexes GetConfig
+        {
+            get {return (LuceneServerIndexes)ConfigurationManager.GetSection("LuceneServerIndexes");}
+        }
 
         /// <summary>
         /// Public constructor for LuceneServerIndexes. A LuceneServerIndex is defined
@@ -58,8 +58,8 @@ namespace Lucene.Net.Distributed.Configuration
         /// </summary>
         /// <param name="xSection">The Xml definition in the configuration file</param>
         public LuceneServerIndexes(XmlNode xSection)
-		{
-			XmlAttributeCollection attributeCollection = xSection.Attributes;
+        {
+            XmlAttributeCollection attributeCollection = xSection.Attributes;
 
             try
             {
@@ -73,37 +73,37 @@ namespace Lucene.Net.Distributed.Configuration
             if (xSection.ChildNodes.Count==0)
                 throw new ConfigurationErrorsException("LuceneServerIndexes configuration missing: " + Environment.NewLine + xSection.OuterXml);
 
-			this._arLuceneServerIndexArray = new LuceneServerIndex[xSection.ChildNodes.Count];
-			int x=0;
+            this._arLuceneServerIndexArray = new LuceneServerIndex[xSection.ChildNodes.Count];
+            int x=0;
 
-			foreach (XmlNode c in xSection.ChildNodes)
-			{
-				if (c.Name.ToLower()=="luceneserverindex")
-				{
-					LuceneServerIndex rs = new LuceneServerIndex(c, _intPort);
-					this._arLuceneServerIndexArray[x] = rs;
-					x++;
-				}
+            foreach (XmlNode c in xSection.ChildNodes)
+            {
+                if (c.Name.ToLower()=="luceneserverindex")
+                {
+                    LuceneServerIndex rs = new LuceneServerIndex(c, _intPort);
+                    this._arLuceneServerIndexArray[x] = rs;
+                    x++;
+                }
 
-			}
-		}
+            }
+        }
 
         /// <summary>
         /// Strongly-typed array of LuceneServerIndex objects as defined in 
         /// a configuration section.
         /// </summary>
-		public LuceneServerIndex[] LuceneServerIndexArray
-		{
-			get {return this._arLuceneServerIndexArray;}
-		}
+        public LuceneServerIndex[] LuceneServerIndexArray
+        {
+            get {return this._arLuceneServerIndexArray;}
+        }
 
         /// <summary>
         /// A default Port to be assigned to all defined LuceneServerIndex objects.
         /// This value can be overridden for a specific LuceneServerIndex.
         /// </summary>
-		public int Port
-		{
-			get {return this._intPort;}
-		}
-	}
+        public int Port
+        {
+            get {return this._intPort;}
+        }
+    }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/contrib/DistributedSearch/Distributed/Enumerations.cs
----------------------------------------------------------------------
diff --git a/src/contrib/DistributedSearch/Distributed/Enumerations.cs b/src/contrib/DistributedSearch/Distributed/Enumerations.cs
index 7e86646..805800e 100644
--- a/src/contrib/DistributedSearch/Distributed/Enumerations.cs
+++ b/src/contrib/DistributedSearch/Distributed/Enumerations.cs
@@ -23,23 +23,23 @@ namespace Lucene.Net.Distributed
     /// <summary>
     /// Specifies the location of a DistributedSearcher
     /// </summary>
-	public enum SearchMethod
-	{
-		Local		= 0,
-		Distributed	= 1,
-		Undefined	= 2
-	}
+    public enum SearchMethod
+    {
+        Local        = 0,
+        Distributed    = 1,
+        Undefined    = 2
+    }
 
     /// <summary>
     /// Specifies the type of Field in an IndexDocument
     /// </summary>
-	public enum FieldStorageType
-	{
-		Keyword		= 1,
-		UnIndexed	= 2,
-		UnStored	= 3,
-		Text		= 4
-	}
+    public enum FieldStorageType
+    {
+        Keyword        = 1,
+        UnIndexed    = 2,
+        UnStored    = 3,
+        Text        = 4
+    }
 
     /// <summary>
     /// Specifies the type of action for an IndexSet to take when applying changes to an index
@@ -54,12 +54,12 @@ namespace Lucene.Net.Distributed
     /// <summary>
     /// Specifies the type of Analyzer to use in creation of an IndexDocument
     /// </summary>
-	public enum AnalyzerType
-	{
-		StandardAnalyzer			= 0,
-		SimpleAnalyzer				= 1,
-		WhitespaceAnalyzer			= 2,
-		StopAnalyzer				= 3
-	}
+    public enum AnalyzerType
+    {
+        StandardAnalyzer            = 0,
+        SimpleAnalyzer                = 1,
+        WhitespaceAnalyzer            = 2,
+        StopAnalyzer                = 3
+    }
 
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/contrib/DistributedSearch/Distributed/Indexing/DeleteIndexDocument.cs
----------------------------------------------------------------------
diff --git a/src/contrib/DistributedSearch/Distributed/Indexing/DeleteIndexDocument.cs b/src/contrib/DistributedSearch/Distributed/Indexing/DeleteIndexDocument.cs
index b3d40f6..8186b36 100644
--- a/src/contrib/DistributedSearch/Distributed/Indexing/DeleteIndexDocument.cs
+++ b/src/contrib/DistributedSearch/Distributed/Indexing/DeleteIndexDocument.cs
@@ -22,14 +22,14 @@ using Lucene.Net.Distributed;
 
 namespace Lucene.Net.Distributed.Indexing
 {
-	[Serializable]
-	public class DeleteIndexDocument: IndexDocument
-	{
+    [Serializable]
+    public class DeleteIndexDocument: IndexDocument
+    {
 
-		public DeleteIndexDocument(int iRecordId)
-			: base(iRecordId)
-		{
-		}
+        public DeleteIndexDocument(int iRecordId)
+            : base(iRecordId)
+        {
+        }
 
-	}
+    }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/contrib/DistributedSearch/Distributed/Indexing/FileNameComparer.cs
----------------------------------------------------------------------
diff --git a/src/contrib/DistributedSearch/Distributed/Indexing/FileNameComparer.cs b/src/contrib/DistributedSearch/Distributed/Indexing/FileNameComparer.cs
index 379d195..24eb329 100644
--- a/src/contrib/DistributedSearch/Distributed/Indexing/FileNameComparer.cs
+++ b/src/contrib/DistributedSearch/Distributed/Indexing/FileNameComparer.cs
@@ -21,24 +21,24 @@ using System.IO;
 
 namespace Lucene.Net.Distributed.Indexing
 {
-	/// <summary>
-	/// Summary description for FileNameComparer.
-	/// </summary>
-	public class FileNameComparer : IComparer
-	{
+    /// <summary>
+    /// Summary description for FileNameComparer.
+    /// </summary>
+    public class FileNameComparer : IComparer
+    {
 
-		public int Compare(object x, object y)
-		{
-			if ((x is FileInfo) && (y is FileInfo))
-			{
-				FileInfo fX = (FileInfo)x;
-				FileInfo fY = (FileInfo)y;
-				return fX.Name.CompareTo(fY.Name);
-			}
-			else
-			{
-				return 0;
-			}
-		}
-	}
+        public int Compare(object x, object y)
+        {
+            if ((x is FileInfo) && (y is FileInfo))
+            {
+                FileInfo fX = (FileInfo)x;
+                FileInfo fY = (FileInfo)y;
+                return fX.Name.CompareTo(fY.Name);
+            }
+            else
+            {
+                return 0;
+            }
+        }
+    }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/contrib/DistributedSearch/Distributed/Indexing/IndexDocument.cs
----------------------------------------------------------------------
diff --git a/src/contrib/DistributedSearch/Distributed/Indexing/IndexDocument.cs b/src/contrib/DistributedSearch/Distributed/Indexing/IndexDocument.cs
index 83a7295..a8c20c8 100644
--- a/src/contrib/DistributedSearch/Distributed/Indexing/IndexDocument.cs
+++ b/src/contrib/DistributedSearch/Distributed/Indexing/IndexDocument.cs
@@ -28,119 +28,119 @@ using Lucene.Net.Distributed;
 namespace Lucene.Net.Distributed.Indexing
 {
 
-	/// <summary>
-	/// Base class representing a record to be added to a Lucene index.
+    /// <summary>
+    /// Base class representing a record to be added to a Lucene index.
     /// <para>
     /// IndexDocument contains a RecordId and a Lucene.Net.Document. The RecordId
     /// is interrogated to determine which index to add the associated 
     /// Lucene.Net.Document.
     /// </para>
-	/// </summary>
-	[Serializable]
-	public abstract class IndexDocument
-	{
-		#region Variables
-		protected Document _oDocument;
-		protected int _intRecordId;
-		public static BinaryFormatter Formatter = new BinaryFormatter();
+    /// </summary>
+    [Serializable]
+    public abstract class IndexDocument
+    {
+        #region Variables
+        protected Document _oDocument;
+        protected int _intRecordId;
+        public static BinaryFormatter Formatter = new BinaryFormatter();
         private static string filepath = (ConfigurationManager.AppSettings["IndexDocumentPath"] != null ? ConfigurationManager.AppSettings["IndexDocumentPath"] : "");
-		private static string endwhack = (filepath.EndsWith(@"\") ? "" : @"\");
-		private DateTime _eDateTime;
-		#endregion
+        private static string endwhack = (filepath.EndsWith(@"\") ? "" : @"\");
+        private DateTime _eDateTime;
+        #endregion
 
-		#region Constructors
+        #region Constructors
         /// <summary>
         /// Empty public constructor.
         /// </summary>
-		public IndexDocument()
-		{
-		}
+        public IndexDocument()
+        {
+        }
 
         /// <summary>
         /// Base constructor accepting only a RecordId. Useful for classes that 
         /// will have no associated Document, i.e. deletes.
         /// </summary>
         /// <param name="iRecordId">The source recordId (see also <seealso cref="#">IndexSet.IdColumn</seealso>) </param>
-		public IndexDocument(int iRecordId)
-		{
-			this._intRecordId = iRecordId;
-			this._oDocument = new Document();
-			this._eDateTime = DateTime.Now;
-		}
+        public IndexDocument(int iRecordId)
+        {
+            this._intRecordId = iRecordId;
+            this._oDocument = new Document();
+            this._eDateTime = DateTime.Now;
+        }
 
-		public IndexDocument(Document oDocument, int iRecordId)
-		{
-			this._oDocument = oDocument;
-			this._intRecordId = iRecordId;
-			this._eDateTime = DateTime.Now;
-		}
+        public IndexDocument(Document oDocument, int iRecordId)
+        {
+            this._oDocument = oDocument;
+            this._intRecordId = iRecordId;
+            this._eDateTime = DateTime.Now;
+        }
 
-		#endregion
+        #endregion
 
-		#region Properties
-		public Document Document
-		{
-			get {return this._oDocument;}
-		}
+        #region Properties
+        public Document Document
+        {
+            get {return this._oDocument;}
+        }
 
-		public int RecordId
-		{
-			get {return this._intRecordId;}
-		}
+        public int RecordId
+        {
+            get {return this._intRecordId;}
+        }
 
         public virtual Analyzer GetAnalyzer()
         {
             return null;
         }
 
-		public string FileName
-		{
-			get { return Environment.MachineName + "_" + this.GetType().ToString() + "_" + this.RecordId.ToString() + "_" + this.DateTime.Ticks.ToString() + ".bin"; }
-		}
-		private DateTime DateTime
-		{
-			get { return this._eDateTime; }
-		}
+        public string FileName
+        {
+            get { return Environment.MachineName + "_" + this.GetType().ToString() + "_" + this.RecordId.ToString() + "_" + this.DateTime.Ticks.ToString() + ".bin"; }
+        }
+        private DateTime DateTime
+        {
+            get { return this._eDateTime; }
+        }
 
-		#endregion
+        #endregion
 
-		#region Methods
-		public void Save()
-		{
-			try
-			{
-				FileStream fs = File.Open(filepath + endwhack + this.FileName, FileMode.Create, FileAccess.ReadWrite);
-				IndexDocument.Formatter.Serialize(fs, this);
-				fs.Close();
-			}
-			catch (SerializationException se)
-			{
-				throw (se);
-			}
-			catch (NullReferenceException nre)
-			{
-				throw (nre);
-			}
-		}
-		public void Save(string filePath)
-		{
-			try
-			{
-				FileStream fs = File.Open(filePath + endwhack + this.FileName, FileMode.Create, FileAccess.ReadWrite);
-				IndexDocument.Formatter.Serialize(fs, this);
-				fs.Close();
-			}
-			catch (SerializationException se)
-			{
-				throw (se);
-			}
-			catch (NullReferenceException nre)
-			{
-				throw (nre);
-			}
-		}
-		#endregion
+        #region Methods
+        public void Save()
+        {
+            try
+            {
+                FileStream fs = File.Open(filepath + endwhack + this.FileName, FileMode.Create, FileAccess.ReadWrite);
+                IndexDocument.Formatter.Serialize(fs, this);
+                fs.Close();
+            }
+            catch (SerializationException se)
+            {
+                throw (se);
+            }
+            catch (NullReferenceException nre)
+            {
+                throw (nre);
+            }
+        }
+        public void Save(string filePath)
+        {
+            try
+            {
+                FileStream fs = File.Open(filePath + endwhack + this.FileName, FileMode.Create, FileAccess.ReadWrite);
+                IndexDocument.Formatter.Serialize(fs, this);
+                fs.Close();
+            }
+            catch (SerializationException se)
+            {
+                throw (se);
+            }
+            catch (NullReferenceException nre)
+            {
+                throw (nre);
+            }
+        }
+        #endregion
 
 
-	}
+    }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/contrib/DistributedSearch/Distributed/Indexing/IndexSet.cs
----------------------------------------------------------------------
diff --git a/src/contrib/DistributedSearch/Distributed/Indexing/IndexSet.cs b/src/contrib/DistributedSearch/Distributed/Indexing/IndexSet.cs
index 01dac8e..3638051 100644
--- a/src/contrib/DistributedSearch/Distributed/Indexing/IndexSet.cs
+++ b/src/contrib/DistributedSearch/Distributed/Indexing/IndexSet.cs
@@ -52,43 +52,43 @@ namespace Lucene.Net.Distributed.Indexing
     /// </code>
     /// </summary>
     public class IndexSet
-	{
-		#region Variables
-		private int _intId = -1;
-		private string _strLocalPath;
-		private string _strIdColumn;
-		private int _intBottomId;
-		private int _intTopId;
-		private CurrentIndex _oCurrentIndex;
-		private IndexAction _eIndexAction=IndexAction.NoAction;
-		private AnalyzerType _eAnalyzerType=AnalyzerType.StandardAnalyzer;
-		private Hashtable _htDocuments = new Hashtable();
-		private Hashtable _htIndexDocuments = new Hashtable();
-		private List<string> _alFileSystemDocuments = new List<string>();
-		#endregion
+    {
+        #region Variables
+        private int _intId = -1;
+        private string _strLocalPath;
+        private string _strIdColumn;
+        private int _intBottomId;
+        private int _intTopId;
+        private CurrentIndex _oCurrentIndex;
+        private IndexAction _eIndexAction=IndexAction.NoAction;
+        private AnalyzerType _eAnalyzerType=AnalyzerType.StandardAnalyzer;
+        private Hashtable _htDocuments = new Hashtable();
+        private Hashtable _htIndexDocuments = new Hashtable();
+        private List<string> _alFileSystemDocuments = new List<string>();
+        #endregion
 
-		#region Constructors
+        #region Constructors
         /// <summary>
         /// Public constructor for IndexSet. An IndexSet is defined in XML configuration 
         /// and is loaded via a custom configuration handler.
         /// </summary>
         /// <param name="node">XmlNode definition for a given IndexSet</param>
         public IndexSet(XmlNode node)
-		{
-			this.LoadValues(node);
-		}
+        {
+            this.LoadValues(node);
+        }
 
-		#endregion
+        #endregion
 
-		#region Internal voids
+        #region Internal voids
         /// <summary>
         /// Internal load method called from the constructor. Loads underlying values
         /// based on Xml configuration.
         /// </summary>
         /// <param name="node">XmlNode definition for a given IndexSet</param>
-		internal void LoadValues(XmlNode node)
-		{
-			XmlAttributeCollection attributeCollection = node.Attributes;
+        internal void LoadValues(XmlNode node)
+        {
+            XmlAttributeCollection attributeCollection = node.Attributes;
             try
             {
                 this._intId = Convert.ToInt32(attributeCollection["id"].Value);
@@ -120,19 +120,19 @@ namespace Lucene.Net.Distributed.Indexing
             if (node.ChildNodes.Count==0)
                 throw new ConfigurationErrorsException("IndexSet " + this._intId.ToString() + " configuration missing " + Environment.NewLine + node.OuterXml);
 
-			foreach (XmlNode c in node.ChildNodes)
-			{
-				if (!c.HasChildNodes)
-				{
-					switch (c.Attributes["key"].Value.ToLower())
-					{
-						case "localpath":
-							this._strLocalPath = c.Attributes["value"].Value;
-							break;
-						case "idcolumn":
-							this._strIdColumn = c.Attributes["value"].Value;
-							break;
-						case "bottomid":
+            foreach (XmlNode c in node.ChildNodes)
+            {
+                if (!c.HasChildNodes)
+                {
+                    switch (c.Attributes["key"].Value.ToLower())
+                    {
+                        case "localpath":
+                            this._strLocalPath = c.Attributes["value"].Value;
+                            break;
+                        case "idcolumn":
+                            this._strIdColumn = c.Attributes["value"].Value;
+                            break;
+                        case "bottomid":
                             try
                             {
                                 this._intBottomId = Convert.ToInt32(c.Attributes["value"].Value);
@@ -141,8 +141,8 @@ namespace Lucene.Net.Distributed.Indexing
                             {
                                 throw new ConfigurationErrorsException("IndexSet " + this._intId.ToString() + " bottomid invalid: " + Environment.NewLine + node.OuterXml);
                             }
-							break;
-						case "topid":
+                            break;
+                        case "topid":
                             try
                             {
                                 this._intTopId = Convert.ToInt32(c.Attributes["value"].Value);
@@ -152,34 +152,34 @@ namespace Lucene.Net.Distributed.Indexing
                                 throw new ConfigurationErrorsException("IndexSet " + this._intId.ToString() + " topid invalid: " + Environment.NewLine + node.OuterXml);
                             }
                             break;
-					}
-				}
-				else
-				{
-					switch(c.Name.ToLower())
-					{
-						case "copy":
-							if (this._strLocalPath!=null)
-								LoadCopy(c,this._strLocalPath);
-							else
-								LoadCopy(c,node);
-							break;
-					}
-				}
-			}
+                    }
+                }
+                else
+                {
+                    switch(c.Name.ToLower())
+                    {
+                        case "copy":
+                            if (this._strLocalPath!=null)
+                                LoadCopy(c,this._strLocalPath);
+                            else
+                                LoadCopy(c,node);
+                            break;
+                    }
+                }
+            }
             this.CheckValidSet(node);
 
-		}
+        }
 
-		internal void LoadCopy(XmlNode node, string localpath)
-		{
-			this._oCurrentIndex = new CurrentIndex(node,localpath);
-		}
+        internal void LoadCopy(XmlNode node, string localpath)
+        {
+            this._oCurrentIndex = new CurrentIndex(node,localpath);
+        }
 
-		internal void LoadCopy(XmlNode node, XmlNode masternode)
-		{
-			foreach (XmlNode c in node.ChildNodes)
-			{
+        internal void LoadCopy(XmlNode node, XmlNode masternode)
+        {
+            foreach (XmlNode c in node.ChildNodes)
+            {
                 if (c.Attributes["key"] != null)
                 {
                     switch (c.Attributes["key"].Value.ToLower())
@@ -189,8 +189,8 @@ namespace Lucene.Net.Distributed.Indexing
                             break;
                     }
                 }
-			}
-		}
+            }
+        }
 
         private void CheckValidSet(XmlNode node)
         {
@@ -199,82 +199,82 @@ namespace Lucene.Net.Distributed.Indexing
             if (this._strIdColumn==null) throw new ConfigurationErrorsException("IndexSet " + this._intId.ToString() + " IdColumn undefined: " + Environment.NewLine + node.OuterXml);
         }
 
-		#endregion
+        #endregion
 
-		#region Properties
+        #region Properties
         /// <summary>
         /// Unique identifier for an IndexSet within a configuration of multiple IndexSet objects
         /// </summary>
-		public int Id
-		{
-			get {return this._intId;}
-		}
+        public int Id
+        {
+            get {return this._intId;}
+        }
 
         /// <summary>
         /// Enumeration dictating the type of updates to be applied to the underlying master index
         /// </summary>
-		public IndexAction IndexAction
-		{
-			get {return this._eIndexAction;}
-		}
+        public IndexAction IndexAction
+        {
+            get {return this._eIndexAction;}
+        }
 
         /// <summary>
         /// Enumeration dictating the type of Analyzer to be applied to IndexDocuments in update scenarios
         /// </summary>
-		public AnalyzerType AnalyzerType
-		{
-			get {return this._eAnalyzerType;}
-		}
+        public AnalyzerType AnalyzerType
+        {
+            get {return this._eAnalyzerType;}
+        }
 
         /// <summary>
         /// The Analyzer object used in application of IndexDocument updates 
         /// </summary>
-		public Analyzer Analzyer
-		{
-			get {return CurrentIndex.GetAnalyzer(this._eAnalyzerType);}
-		}
+        public Analyzer Analzyer
+        {
+            get {return CurrentIndex.GetAnalyzer(this._eAnalyzerType);}
+        }
 
         /// <summary>
         /// Filesystem path to the master index
         /// </summary>
-		public string LocalPath
-		{
-			get {return this._strLocalPath;}
-		}
+        public string LocalPath
+        {
+            get {return this._strLocalPath;}
+        }
 
         /// <summary>
         /// String name representing the unique key for the given record in the index
         /// </summary>
-		public string IdColumn
-		{
-			get {return this._strIdColumn;}
-		}
+        public string IdColumn
+        {
+            get {return this._strIdColumn;}
+        }
 
         /// <summary>
         /// Minimum IdColumn value for a record in this index
         /// </summary>
-		public int BottomId
-		{
-			get {return this._intBottomId;}
-		}
+        public int BottomId
+        {
+            get {return this._intBottomId;}
+        }
 
         /// <summary>
         /// Maximum IdColumn value for a record in this index
         /// </summary>
-		public int TopId
-		{
-			get {return this._intTopId;}
-		}
+        public int TopId
+        {
+            get {return this._intTopId;}
+        }
 
         /// <summary>
         /// CurrentIndex object associated with this IndexSet.  The CurrentIndex is used
         /// in determining index settings and maintenance as well as managing physical file updates
         /// for index updates.
         /// </summary>
-		public CurrentIndex CurrentIndex
-		{
-			get {return this._oCurrentIndex;}
-		}
+        public CurrentIndex CurrentIndex
+        {
+            get {return this._oCurrentIndex;}
+        }
 
         /// <summary>
         /// List of filesystem paths representing files for the master index
@@ -318,21 +318,21 @@ namespace Lucene.Net.Distributed.Indexing
         /// </summary>
         /// <returns></returns>
         public NameValueCollection GetDeletionCollection()
-		{
-			NameValueCollection nvc = new NameValueCollection(this._htDocuments.Count);
-			foreach(DictionaryEntry de in this._htIndexDocuments)
-				nvc.Add(this.IdColumn, ((IndexDocument)de.Value).RecordId.ToString());
-			return nvc;
-		}
+        {
+            NameValueCollection nvc = new NameValueCollection(this._htDocuments.Count);
+            foreach(DictionaryEntry de in this._htIndexDocuments)
+                nvc.Add(this.IdColumn, ((IndexDocument)de.Value).RecordId.ToString());
+            return nvc;
+        }
 
         /// <summary>
         /// Clears the contents of Documents and IndexDocuments
         /// </summary>
-		public void Reset()
-		{
-			this._htIndexDocuments.Clear();
-			this._htDocuments.Clear();
-		}
+        public void Reset()
+        {
+            this._htIndexDocuments.Clear();
+            this._htDocuments.Clear();
+        }
 
         /// <summary>
         /// Executes a Lucene.Net optimization against the referenced index.

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/contrib/DistributedSearch/Distributed/Indexing/IndexSetConfigurationHandler.cs
----------------------------------------------------------------------
diff --git a/src/contrib/DistributedSearch/Distributed/Indexing/IndexSetConfigurationHandler.cs b/src/contrib/DistributedSearch/Distributed/Indexing/IndexSetConfigurationHandler.cs
index dab927b..2ae90fd 100644
--- a/src/contrib/DistributedSearch/Distributed/Indexing/IndexSetConfigurationHandler.cs
+++ b/src/contrib/DistributedSearch/Distributed/Indexing/IndexSetConfigurationHandler.cs
@@ -27,20 +27,20 @@ namespace Lucene.Net.Distributed.Indexing
     /// as managed by the LuceneUpdater windows service.
     /// </summary>
     public class IndexSetConfigurationHandler : IConfigurationSectionHandler
-	{
-		public IndexSetConfigurationHandler()
-		{
-		}
+    {
+        public IndexSetConfigurationHandler()
+        {
+        }
 
-		#region IConfigurationSectionHandler Members
+        #region IConfigurationSectionHandler Members
 
-		public object Create(object parent, object configContext, XmlNode section)
-		{
+        public object Create(object parent, object configContext, XmlNode section)
+        {
             IndexSets isConfig = new IndexSets();
             isConfig.LoadIndexSetArray(section);
             return isConfig;
-		}
+        }
 
-		#endregion
-	}
+        #endregion
+    }
 }


Mime
View raw message