fixing xml comments and letting ReSharper do reformatting

SVN: trunk@1162

Author: Kevin Williams

src/NHibernate/Cache/CacheException.cs

@@ -8,11 +8,19 @@ namespace NHibernate.Cache
 	[Serializable]
 	public class CacheException : HibernateException
 	{
-		public CacheException(string message) : base( message )
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="message"></param>
+		public CacheException( string message ) : base( message )
 		{
 		}
 
-		public CacheException(Exception e) : base( e )
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="e"></param>
+		public CacheException( Exception e ) : base( e )
 		{
 		}
 	}

src/NHibernate/Cache/CacheFactory.cs

@@ -1,5 +1,5 @@
-using System;
 using System.Xml;
+using log4net;
 
 namespace NHibernate.Cache
 {
@@ -8,15 +8,18 @@ namespace NHibernate.Cache
 	/// </summary>
 	public class CacheFactory
 	{
-		private static readonly log4net.ILog log = log4net.LogManager.GetLogger( typeof(CacheFactory) );
+		private static readonly ILog log = LogManager.GetLogger( typeof( CacheFactory ) );
 
 		private CacheFactory()
 		{
 			// not publically creatable
 		}
 
+		/// <summary></summary>
 		public const string ReadOnly = "read-only";
+		/// <summary></summary>
 		public const string ReadWrite = "read-write";
+		/// <summary></summary>
 		public const string NonstrictReadWrite = "nonstrict-read-write";
 
 		/// <summary>
@@ -26,11 +29,11 @@ private CacheFactory()
 		/// <param name="name">The name of the class the strategy is being created for.</param>
 		/// <param name="mutable"><c>true</c> if the object being stored in the cache is mutable.</param>
 		/// <returns>An <see cref="ICacheConcurrencyStrategy"/> to use for this object in the <see cref="ICache"/>.</returns>
-		public static ICacheConcurrencyStrategy CreateCache(XmlNode node, string name, bool mutable) 
+		public static ICacheConcurrencyStrategy CreateCache( XmlNode node, string name, bool mutable )
 		{
-			return CacheFactory.CreateCache( node.Attributes["usage"].Value, name, mutable );
+			return CacheFactory.CreateCache( node.Attributes[ "usage" ].Value, name, mutable );
 		}
-		
+
 		/// <summary>
 		/// Creates an <see cref="ICacheConcurrencyStrategy"/> from the parameters.
 		/// </summary>
@@ -39,36 +42,36 @@ public static ICacheConcurrencyStrategy CreateCache(XmlNode node, string name, b
 		/// <param name="mutable"><c>true</c> if the object being stored in the cache is mutable.</param>
 		/// <returns>An <see cref="ICacheConcurrencyStrategy"/> to use for this object in the <see cref="ICache"/>.</returns>
 		// was private in h2.1
-		public static ICacheConcurrencyStrategy CreateCache(string usage, string name, bool mutable) 
+		public static ICacheConcurrencyStrategy CreateCache( string usage, string name, bool mutable )
 		{
-			if( log.IsDebugEnabled ) 
+			if( log.IsDebugEnabled )
 			{
 				log.Debug( "cache for: " + name + "usage strategy: " + usage );
 			}
-		
+
 			ICacheConcurrencyStrategy ccs = null;
-			switch( usage ) 
+			switch( usage )
 			{
-				case CacheFactory.ReadOnly :
-					if( mutable ) 
+				case CacheFactory.ReadOnly:
+					if( mutable )
 					{
 						log.Warn( "read-only cache configured for mutable: " + name );
 					}
 					ccs = new ReadOnlyCache();
 					break;
-				case CacheFactory.ReadWrite :
+				case CacheFactory.ReadWrite:
 					ccs = new ReadWriteCache();
 					break;
-				case CacheFactory.NonstrictReadWrite :
+				case CacheFactory.NonstrictReadWrite:
 					ccs = new NonstrictReadWriteCache();
 					break;
-				default :
+				default:
 					throw new MappingException( "cache usage attribute should be read-write, read-only, nonstrict-read-write, or transactional" );
 			}
 
 			return ccs;
-		
+
 		}
 
 	}
-}
+}

src/NHibernate/Cache/CachedItem.cs

@@ -15,6 +15,10 @@ public class CachedItem
 		private int theLock;
 		private object value;
 
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="value"></param>
 		public CachedItem(object value)
 		{
 			this.value = value;
@@ -31,6 +35,9 @@ public long FreshTimestamp
 			get { return freshTimestamp; }
 		}
 
+		/// <summary>
+		/// 
+		/// </summary>
 		public long UnlockTimestamp
 		{
 			get { return unlockTimestamp; }

src/NHibernate/Cache/HashtableCache.cs

@@ -1,40 +1,46 @@
-using System;
 using System.Collections;
-using System.Runtime.CompilerServices;
 
-namespace NHibernate.Cache 
+namespace NHibernate.Cache
 {
 	/// <summary>
 	/// A simple <c>Hashtable</c> based cache
 	/// </summary>
 	public class HashtableCache : ICache
 	{
-		private static object synchObject = new object();
+//		private static object synchObject = new object();
 		private Hashtable cache = new Hashtable();
 		private string region;
 
-		public HashtableCache(string region) 
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="region"></param>
+		public HashtableCache( string region )
 		{
 			this.region = region;
 		}
 
 		#region ICache Members
-		
-		public object Get(object key) 
+
+		/// <summary></summary>
+		public object Get( object key )
 		{
-			return cache[key];
+			return cache[ key ];
 		}
 
-		public void Put(object key, object value) 
+		/// <summary></summary>
+		public void Put( object key, object value )
 		{
-			cache[key] = value;
+			cache[ key ] = value;
 		}
 
-		public void Remove(object key)
+		/// <summary></summary>
+		public void Remove( object key )
 		{
-			cache.Remove(key);
+			cache.Remove( key );
 		}
 
+		/// <summary></summary>
 		public void Clear()
 		{
 			cache.Clear();
@@ -48,11 +54,12 @@ public void Destroy()
 			cache = new Hashtable();
 		}
 
+		/// <summary></summary>
 		public string Region
 		{
-			set	{ region = value; }
+			set { region = value; }
 		}
 
 		#endregion
 	}
-}
+}

src/NHibernate/Cache/HashtableCacheProvider.cs

@@ -1,7 +1,6 @@
-using System;
 using System.Collections;
 
-namespace NHibernate.Cache 
+namespace NHibernate.Cache
 {
 	/// <summary>
 	/// Cache Provider plugin for NHibernate that is configured by using
@@ -11,16 +10,26 @@ public class HashtableCacheProvider : ICacheProvider
 	{
 		#region ICacheProvider Members
 
-		public ICache BuildCache(string regionName, IDictionary properties)
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="regionName"></param>
+		/// <param name="properties"></param>
+		/// <returns></returns>
+		public ICache BuildCache( string regionName, IDictionary properties )
 		{
 			return new HashtableCache( regionName );
 		}
 
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <returns></returns>
 		public long NextTimestamp()
 		{
 			return Timestamper.Next();
 		}
 
 		#endregion
 	}
-}
+}

src/NHibernate/Cache/ICache.cs

@@ -1,6 +1,4 @@
-using System;
-
-namespace NHibernate.Cache 
+namespace NHibernate.Cache
 {
 	/// <summary>
 	/// Implementors define a caching algorithm.
@@ -13,24 +11,28 @@ namespace NHibernate.Cache
 	/// value is a <see cref="CachedItem"/>.
 	/// </para>
 	/// </remarks>
-	public interface ICache 
+	public interface ICache
 	{
-
 		/// <summary>
 		/// Get the object from the Cache
 		/// </summary>
 		/// <param name="key"></param>
 		/// <returns></returns>
-		object Get(object key);
+		object Get( object key );
 
-		void Put(object key, object value);
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="value"></param>
+		void Put( object key, object value );
 
 		/// <summary>
 		/// Remove an item from the Cache.
 		/// </summary>
 		/// <param name="key">The Key of the Item in the Cache to remove.</param>
 		/// <exception cref="CacheException"></exception>
-		void Remove(object key);
+		void Remove( object key );
 
 		/// <summary>
 		/// Clear the Cache
@@ -48,9 +50,9 @@ public interface ICache
 		/// Sets the Cache Region name.
 		/// </summary>
 		/// <exception cref="CacheException"></exception>
-		string Region {set;}
+		string Region { set; }
 
 	}
 
 
-}
+}

src/NHibernate/Cache/ICacheConcurrencyStrategy.cs

@@ -1,6 +1,4 @@
-using System;
-
-namespace NHibernate.Cache 
+namespace NHibernate.Cache
 {
 	/// <summary>
 	/// Implementors manage transactional access to cached data.
@@ -15,16 +13,16 @@ namespace NHibernate.Cache
 	/// for an Entity and the results of <see cref="Collection.PersistentCollection"/>.Disassemble for a Collection.
 	/// </para>
 	/// </remarks>
-	public interface ICacheConcurrencyStrategy 
-	{		
+	public interface ICacheConcurrencyStrategy
+	{
 		/// <summary>
 		/// Attempt to retrieve an object from the Cache
 		/// </summary>
 		/// <param name="key">The key (id) of the object to get out of the Cache.</param>
 		/// <param name="txTimestamp">A timestamp prior to the transaction start time</param>
 		/// <returns>The cached object or <c>null</c></returns>
 		/// <exception cref="CacheException"></exception>
-		object Get(object key, long txTimestamp);
+		object Get( object key, long txTimestamp );
 
 		/// <summary>
 		/// Attempt to Cache an object 
@@ -34,28 +32,28 @@ public interface ICacheConcurrencyStrategy
 		/// <param name="txTimestamp">A timestamp prior to the transaction start time</param>
 		/// <returns><c>true</c> if the object was successfully cached</returns>
 		/// <exception cref="CacheException"></exception>
-		bool Put(object key, object value, long txTimestamp);
+		bool Put( object key, object value, long txTimestamp );
 
 		/// <summary>
 		/// We are going to attempt to update/delete the keyed object
 		/// </summary>
 		/// <param name="key">The key</param>
 		/// <exception cref="CacheException"></exception>
-		void Lock(object key);
+		void Lock( object key );
 
 		/// <summary>
 		/// We have finished the attempted update/delete (which may or may not have been successful)
 		/// </summary>
 		/// <param name="key">The key</param>
 		/// <exception cref="CacheException"></exception>
-		void Release(object key);
+		void Release( object key );
 
 		/// <summary>
 		/// 
 		/// </summary>
 		/// <param name="key"></param>
 		/// <exception cref="CacheException"></exception>
-		void Remove(object key);
+		void Remove( object key );
 
 		/// <summary>
 		/// 
@@ -73,6 +71,6 @@ public interface ICacheConcurrencyStrategy
 		/// Gets or sets the <see cref="ICache"/> for this strategy to use.
 		/// </summary>
 		/// <value>The <see cref="ICache"/> for this strategy to use.</value>
-		ICache Cache { get; set ;}
+		ICache Cache { get; set; }
 	}
-}
+}