Renamed IBatchableReadWriteCache to IBatchableCache and IBatchableReadCache to IBatchableReadOnlyCache

maca88 · maca88 · commit fae4917fc961 · 2018-06-01T23:05:57.000+02:00
diff --git a/src/AsyncGenerator.yml b/src/AsyncGenerator.yml
@@ -258,8 +258,8 @@ methodRules:
     name: Lock
   - containingType: NHibernate.Cache.ICache
     name: Unlock
-  - containingType: NHibernate.Cache.IBatchableReadCache
-  - containingType: NHibernate.Cache.IBatchableReadWriteCache
+  - containingType: NHibernate.Cache.IBatchableReadOnlyCache
+  - containingType: NHibernate.Cache.IBatchableCache
   name: Cache
 - filters:
   - containingNamespace: NHibernate
diff --git a/src/NHibernate.Test/Async/CacheTest/Caches/BatchableCache.cs b/src/NHibernate.Test/Async/CacheTest/Caches/BatchableCache.cs
@@ -19,7 +19,7 @@
 
 namespace NHibernate.Test.CacheTest.Caches
 {
-	public partial class BatchableCache : ICache, IBatchableReadWriteCache
+	public partial class BatchableCache : ICache, IBatchableCache
 	{
 
 		public Task PutManyAsync(object[] keys, object[] values, CancellationToken cancellationToken)
diff --git a/src/NHibernate.Test/CacheTest/Caches/BatchableCache.cs b/src/NHibernate.Test/CacheTest/Caches/BatchableCache.cs
@@ -9,7 +9,7 @@
 
 namespace NHibernate.Test.CacheTest.Caches
 {
-	public partial class BatchableCache : ICache, IBatchableReadWriteCache
+	public partial class BatchableCache : ICache, IBatchableCache
 	{
 		private readonly IDictionary _hashtable = new Hashtable();
 
diff --git a/src/NHibernate/Async/Cache/IBatchableCache.cs b/src/NHibernate/Async/Cache/IBatchableCache.cs
@@ -16,7 +16,7 @@ namespace NHibernate.Cache
 {
 	using System.Threading.Tasks;
 	using System.Threading;
-	public partial interface IBatchableReadWriteCache : IBatchableReadCache
+	public partial interface IBatchableCache : IBatchableReadOnlyCache
 	{
 		/// <summary>
 		/// Add multiple objects to the cache.
diff --git a/src/NHibernate/Async/Cache/IBatchableReadOnlyCache.cs b/src/NHibernate/Async/Cache/IBatchableReadOnlyCache.cs
@@ -16,7 +16,7 @@ namespace NHibernate.Cache
 {
 	using System.Threading.Tasks;
 	using System.Threading;
-	public partial interface IBatchableReadCache
+	public partial interface IBatchableReadOnlyCache
 	{
 		/// <summary>
 		/// Get multiple objects from the cache.
diff --git a/src/NHibernate/Async/Cache/NonstrictReadWriteCache.cs b/src/NHibernate/Async/Cache/NonstrictReadWriteCache.cs
@@ -46,7 +46,7 @@ public async Task<object> GetAsync(CacheKey key, long txTimestamp, CancellationT
 
 		public Task<object[]> GetManyAsync(CacheKey[] keys, long timestamp, CancellationToken cancellationToken)
 		{
-			if (_batchableReadCache == null)
+			if (_batchableReadOnlyCache == null)
 			{
 				throw new InvalidOperationException($"Cache {cache.GetType()} does not support batching get operation");
 			}
@@ -61,7 +61,7 @@ async Task<object[]> InternalGetManyAsync()
 				{
 					log.Debug("Cache lookup: {0}", string.Join(",", keys.AsEnumerable()));
 				}
-				var results = await (_batchableReadCache.GetManyAsync(keys.Select(o => (object) o).ToArray(), cancellationToken)).ConfigureAwait(false);
+				var results = await (_batchableReadOnlyCache.GetManyAsync(keys.Select(o => (object) o).ToArray(), cancellationToken)).ConfigureAwait(false);
 				if (!log.IsDebugEnabled())
 				{
 					return results;
@@ -80,7 +80,7 @@ async Task<object[]> InternalGetManyAsync()
 		public Task<bool[]> PutManyAsync(CacheKey[] keys, object[] values, long timestamp, object[] versions, IComparer[] versionComparers,
 		                          bool[] minimalPuts, CancellationToken cancellationToken)
 		{
-			if (_batchableReadWriteCache == null)
+			if (_batchableCache == null)
 			{
 				throw new InvalidOperationException($"Cache {cache.GetType()} does not support batching operations");
 			}
@@ -111,7 +111,7 @@ async Task<bool[]> InternalPutManyAsync()
 				var skipKeyIndexes = new HashSet<int>();
 				if (checkKeys.Any())
 				{
-					var objects = await (_batchableReadWriteCache.GetManyAsync(checkKeys.ToArray(), cancellationToken)).ConfigureAwait(false);
+					var objects = await (_batchableCache.GetManyAsync(checkKeys.ToArray(), cancellationToken)).ConfigureAwait(false);
 					for (var i = 0; i < objects.Length; i++)
 					{
 						if (objects[i] != null)
@@ -143,7 +143,7 @@ async Task<bool[]> InternalPutManyAsync()
 					putValues[j++] = values[i];
 					result[i] = true;
 				}
-				await (_batchableReadWriteCache.PutManyAsync(putKeys, putValues, cancellationToken)).ConfigureAwait(false);
+				await (_batchableCache.PutManyAsync(putKeys, putValues, cancellationToken)).ConfigureAwait(false);
 				return result;
 			}
 		}
diff --git a/src/NHibernate/Async/Cache/ReadOnlyCache.cs b/src/NHibernate/Async/Cache/ReadOnlyCache.cs
@@ -34,7 +34,7 @@ public async Task<object> GetAsync(CacheKey key, long timestamp, CancellationTok
 
 		public Task<object[]> GetManyAsync(CacheKey[] keys, long timestamp, CancellationToken cancellationToken)
 		{
-			if (_batchableReadCache == null)
+			if (_batchableReadOnlyCache == null)
 			{
 				throw new InvalidOperationException($"Cache {cache.GetType()} does not support batching get operation");
 			}
@@ -49,7 +49,7 @@ async Task<object[]> InternalGetManyAsync()
 				{
 					log.Debug("Cache lookup: {0}", string.Join(",", keys.AsEnumerable()));
 				}
-				var results = await (_batchableReadCache.GetManyAsync(keys.Select(o => (object) o).ToArray(), cancellationToken)).ConfigureAwait(false);
+				var results = await (_batchableReadOnlyCache.GetManyAsync(keys.Select(o => (object) o).ToArray(), cancellationToken)).ConfigureAwait(false);
 				if (!log.IsDebugEnabled())
 				{
 					return results;
@@ -84,7 +84,7 @@ public Task<ISoftLock> LockAsync(CacheKey key, object version, CancellationToken
 		public Task<bool[]> PutManyAsync(CacheKey[] keys, object[] values, long timestamp, object[] versions, IComparer[] versionComparers,
 		                          bool[] minimalPuts, CancellationToken cancellationToken)
 		{
-			if (_batchableReadWriteCache == null)
+			if (_batchableCache == null)
 			{
 				throw new InvalidOperationException($"Cache {cache.GetType()} does not support batching operations");
 			}
@@ -115,7 +115,7 @@ async Task<bool[]> InternalPutManyAsync()
 				var skipKeyIndexes = new HashSet<int>();
 				if (checkKeys.Any())
 				{
-					var objects = await (_batchableReadWriteCache.GetManyAsync(checkKeys.Select(o => (object) o).ToArray(), cancellationToken)).ConfigureAwait(false);
+					var objects = await (_batchableCache.GetManyAsync(checkKeys.Select(o => (object) o).ToArray(), cancellationToken)).ConfigureAwait(false);
 					for (var i = 0; i < objects.Length; i++)
 					{
 						if (objects[i] != null)
@@ -147,7 +147,7 @@ async Task<bool[]> InternalPutManyAsync()
 					putValues[j++] = values[i];
 					result[i] = true;
 				}
-				await (_batchableReadWriteCache.PutManyAsync(putKeys, putValues, cancellationToken)).ConfigureAwait(false);
+				await (_batchableCache.PutManyAsync(putKeys, putValues, cancellationToken)).ConfigureAwait(false);
 				return result;
 			}
 		}
diff --git a/src/NHibernate/Async/Cache/ReadWriteCache.cs b/src/NHibernate/Async/Cache/ReadWriteCache.cs
@@ -92,7 +92,7 @@ public async Task<object> GetAsync(CacheKey key, long txTimestamp, CancellationT
 
 		public Task<object[]> GetManyAsync(CacheKey[] keys, long timestamp, CancellationToken cancellationToken)
 		{
-			if (_batchableReadCache == null)
+			if (_batchableReadOnlyCache == null)
 			{
 				throw new InvalidOperationException($"Cache {cache.GetType()} does not support batching get operation");
 			}
@@ -110,7 +110,7 @@ async Task<object[]> InternalGetManyAsync()
 				var result = new object[keys.Length];
 				using (await _lockObjectAsync.LockAsync())
 				{
-					var lockables = await (_batchableReadCache.GetManyAsync(keys.Select(o => (object) o).ToArray(), cancellationToken)).ConfigureAwait(false);
+					var lockables = await (_batchableReadOnlyCache.GetManyAsync(keys.Select(o => (object) o).ToArray(), cancellationToken)).ConfigureAwait(false);
 					for (var i = 0; i < lockables.Length; i++)
 					{
 						var lockable = (ILockable) lockables[i];
@@ -183,7 +183,7 @@ public async Task<ISoftLock> LockAsync(CacheKey key, object version, Cancellatio
 		public Task<bool[]> PutManyAsync(CacheKey[] keys, object[] values, long timestamp, object[] versions, IComparer[] versionComparers,
 		                bool[] minimalPuts, CancellationToken cancellationToken)
 		{
-			if (_batchableReadWriteCache == null)
+			if (_batchableCache == null)
 			{
 				throw new InvalidOperationException($"Cache {cache.GetType()} does not support batching operations");
 			}
@@ -211,9 +211,9 @@ async Task<bool[]> InternalPutManyAsync()
 					var keysArr = keys.Cast<object>().ToArray();
 					try
 					{
-						await (_batchableReadWriteCache.LockManyAsync(keysArr, cancellationToken)).ConfigureAwait(false);
+						await (_batchableCache.LockManyAsync(keysArr, cancellationToken)).ConfigureAwait(false);
 						var putBatch = new Dictionary<object, object>();
-						var lockables = await (_batchableReadWriteCache.GetManyAsync(keysArr, cancellationToken)).ConfigureAwait(false);
+						var lockables = await (_batchableCache.GetManyAsync(keysArr, cancellationToken)).ConfigureAwait(false);
 						for (var i = 0; i < keys.Length; i++)
 						{
 							var key = keys[i];
@@ -249,12 +249,12 @@ async Task<bool[]> InternalPutManyAsync()
 
 						if (putBatch.Count > 0)
 						{
-							await (_batchableReadWriteCache.PutManyAsync(putBatch.Keys.ToArray(), putBatch.Values.ToArray(), cancellationToken)).ConfigureAwait(false);
+							await (_batchableCache.PutManyAsync(putBatch.Keys.ToArray(), putBatch.Values.ToArray(), cancellationToken)).ConfigureAwait(false);
 						}
 					}
 					finally
 					{
-						await (_batchableReadWriteCache.UnlockManyAsync(keysArr, cancellationToken)).ConfigureAwait(false);
+						await (_batchableCache.UnlockManyAsync(keysArr, cancellationToken)).ConfigureAwait(false);
 					}
 				}
 				return result;
diff --git a/src/NHibernate/Async/Engine/BatchFetchQueue.cs b/src/NHibernate/Async/Engine/BatchFetchQueue.cs
@@ -66,7 +66,7 @@ internal async Task<object[]> GetCollectionBatchAsync(ICollectionPersister colle
 			// List of collection entries that haven't been checked for their existance in the cache. Besides the collection entry,
 			// the index where the entry was found is also stored in order to correctly order the returning keys.
 			var collectionKeys = new List<KeyValuePair<KeyValuePair<CollectionEntry, IPersistentCollection>, int>>(batchSize);
-			var batchableCache = collectionPersister.Cache?.Cache as IBatchableReadCache;
+			var batchableCache = collectionPersister.Cache?.Cache as IBatchableReadOnlyCache;
 
 			if (!batchLoadableCollections.TryGetValue(collectionPersister.Role, out var map))
 			{
@@ -258,7 +258,7 @@ internal async Task<object[]> GetEntityBatchAsync(IEntityPersister persister, ob
 			// List of entity keys that haven't been checked for their existance in the cache. Besides the entity key,
 			// the index where the key was found is also stored in order to correctly order the returning keys.
 			var entityKeys = new List<KeyValuePair<EntityKey, int>>(batchSize);
-			var batchableCache = persister.Cache?.Cache as IBatchableReadCache;
+			var batchableCache = persister.Cache?.Cache as IBatchableReadOnlyCache;
 
 			if (!batchLoadableEntityKeys.TryGetValue(persister.EntityName, out var set))
 			{
@@ -412,7 +412,7 @@ private async Task<bool> IsCachedAsync(object collectionKey, ICollectionPersiste
 		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
 		/// <returns>An array of booleans that contains the result for each key.</returns>
 		private async Task<bool[]> AreCachedAsync(List<KeyValuePair<EntityKey, int>> entityKeys, int[] keyIndexes, IEntityPersister persister,
-		                         IBatchableReadCache batchableCache, bool checkCache, CancellationToken cancellationToken)
+		                         IBatchableReadOnlyCache batchableCache, bool checkCache, CancellationToken cancellationToken)
 		{
 			cancellationToken.ThrowIfCancellationRequested();
 			var result = new bool[keyIndexes.Length];
@@ -450,7 +450,7 @@ private async Task<bool[]> AreCachedAsync(List<KeyValuePair<EntityKey, int>> ent
 		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
 		/// <returns>An array of booleans that contains the result for each key.</returns>
 		private async Task<bool[]> AreCachedAsync(List<KeyValuePair<KeyValuePair<CollectionEntry, IPersistentCollection>, int>> collectionKeys,
-		                         int[] keyIndexes, ICollectionPersister persister, IBatchableReadCache batchableCache,
+		                         int[] keyIndexes, ICollectionPersister persister, IBatchableReadOnlyCache batchableCache,
 		                         bool checkCache, CancellationToken cancellationToken)
 		{
 			cancellationToken.ThrowIfCancellationRequested();
diff --git a/src/NHibernate/Cache/IBatchableCache.cs b/src/NHibernate/Cache/IBatchableCache.cs
@@ -15,7 +15,7 @@ namespace NHibernate.Cache
 	/// All implementations <em>must</em> be threadsafe.
 	/// </para>
 	/// </remarks>
-	public partial interface IBatchableReadWriteCache : IBatchableReadCache
+	public partial interface IBatchableCache : IBatchableReadOnlyCache
 	{
 		/// <summary>
 		/// Add multiple objects to the cache.
diff --git a/src/NHibernate/Cache/IBatchableReadOnlyCache.cs b/src/NHibernate/Cache/IBatchableReadOnlyCache.cs
@@ -15,7 +15,7 @@ namespace NHibernate.Cache
 	/// All implementations <em>must</em> be threadsafe.
 	/// </para>
 	/// </remarks>
-	public partial interface IBatchableReadCache
+	public partial interface IBatchableReadOnlyCache
 	{
 		/// <summary>
 		/// Get multiple objects from the cache.
diff --git a/src/NHibernate/Cache/ICacheConcurrencyStrategy.cs b/src/NHibernate/Cache/ICacheConcurrencyStrategy.cs
@@ -185,13 +185,13 @@ public static bool[] PutMany(this ICacheConcurrencyStrategy cache, CacheKey[] ke
 		public static bool IsBatchingGetSupported(this ICacheConcurrencyStrategy cache)
 		{
 			// ReSharper disable once SuspiciousTypeConversion.Global
-			return cache is IBatchableCacheConcurrencyStrategy && cache.Cache is IBatchableReadCache;
+			return cache is IBatchableCacheConcurrencyStrategy && cache.Cache is IBatchableReadOnlyCache;
 		}
 
 		public static bool IsBatchingPutSupported(this ICacheConcurrencyStrategy cache)
 		{
 			// ReSharper disable once SuspiciousTypeConversion.Global
-			return cache is IBatchableCacheConcurrencyStrategy && cache.Cache is IBatchableReadWriteCache;
+			return cache is IBatchableCacheConcurrencyStrategy && cache.Cache is IBatchableCache;
 		}
 	}
 }
diff --git a/src/NHibernate/Cache/NonstrictReadWriteCache.cs b/src/NHibernate/Cache/NonstrictReadWriteCache.cs
@@ -17,8 +17,8 @@ namespace NHibernate.Cache
 	public partial class NonstrictReadWriteCache : IBatchableCacheConcurrencyStrategy
 	{
 		private ICache cache;
-		private IBatchableReadCache _batchableReadCache;
-		private IBatchableReadWriteCache _batchableReadWriteCache;
+		private IBatchableReadOnlyCache _batchableReadOnlyCache;
+		private IBatchableCache _batchableCache;
 
 		private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(NonstrictReadWriteCache));
 
@@ -37,8 +37,8 @@ public ICache Cache
 			{
 				cache = value;
 				// ReSharper disable once SuspiciousTypeConversion.Global
-				_batchableReadCache = value as IBatchableReadCache;
-				_batchableReadWriteCache = value as IBatchableReadWriteCache;
+				_batchableReadOnlyCache = value as IBatchableReadOnlyCache;
+				_batchableCache = value as IBatchableCache;
 			}
 		}
 
@@ -66,15 +66,15 @@ public object Get(CacheKey key, long txTimestamp)
 
 		public object[] GetMany(CacheKey[] keys, long timestamp)
 		{
-			if (_batchableReadCache == null)
+			if (_batchableReadOnlyCache == null)
 			{
 				throw new InvalidOperationException($"Cache {cache.GetType()} does not support batching get operation");
 			}
 			if (log.IsDebugEnabled())
 			{
 				log.Debug("Cache lookup: {0}", string.Join(",", keys.AsEnumerable()));
 			}
-			var results = _batchableReadCache.GetMany(keys.Select(o => (object) o).ToArray());
+			var results = _batchableReadOnlyCache.GetMany(keys.Select(o => (object) o).ToArray());
 			if (!log.IsDebugEnabled())
 			{
 				return results;
@@ -92,7 +92,7 @@ public object[] GetMany(CacheKey[] keys, long timestamp)
 		public bool[] PutMany(CacheKey[] keys, object[] values, long timestamp, object[] versions, IComparer[] versionComparers,
 		                          bool[] minimalPuts)
 		{
-			if (_batchableReadWriteCache == null)
+			if (_batchableCache == null)
 			{
 				throw new InvalidOperationException($"Cache {cache.GetType()} does not support batching operations");
 			}
@@ -116,7 +116,7 @@ public bool[] PutMany(CacheKey[] keys, object[] values, long timestamp, object[]
 			var skipKeyIndexes = new HashSet<int>();
 			if (checkKeys.Any())
 			{
-				var objects = _batchableReadWriteCache.GetMany(checkKeys.ToArray());
+				var objects = _batchableCache.GetMany(checkKeys.ToArray());
 				for (var i = 0; i < objects.Length; i++)
 				{
 					if (objects[i] != null)
@@ -148,7 +148,7 @@ public bool[] PutMany(CacheKey[] keys, object[] values, long timestamp, object[]
 				putValues[j++] = values[i];
 				result[i] = true;
 			}
-			_batchableReadWriteCache.PutMany(putKeys, putValues);
+			_batchableCache.PutMany(putKeys, putValues);
 			return result;
 		}
 
diff --git a/src/NHibernate/Cache/ReadOnlyCache.cs b/src/NHibernate/Cache/ReadOnlyCache.cs
@@ -12,8 +12,8 @@ namespace NHibernate.Cache
 	public partial class ReadOnlyCache : IBatchableCacheConcurrencyStrategy
 	{
 		private ICache cache;
-		private IBatchableReadCache _batchableReadCache;
-		private IBatchableReadWriteCache _batchableReadWriteCache;
+		private IBatchableReadOnlyCache _batchableReadOnlyCache;
+		private IBatchableCache _batchableCache;
 		private static readonly INHibernateLogger log = NHibernateLogger.For(typeof(ReadOnlyCache));
 
 		/// <summary>
@@ -31,8 +31,8 @@ public ICache Cache
 			{
 				cache = value;
 				// ReSharper disable once SuspiciousTypeConversion.Global
-				_batchableReadCache = value as IBatchableReadCache;
-				_batchableReadWriteCache = value as IBatchableReadWriteCache;
+				_batchableReadOnlyCache = value as IBatchableReadOnlyCache;
+				_batchableCache = value as IBatchableCache;
 			}
 		}
 
@@ -48,15 +48,15 @@ public object Get(CacheKey key, long timestamp)
 
 		public object[] GetMany(CacheKey[] keys, long timestamp)
 		{
-			if (_batchableReadCache == null)
+			if (_batchableReadOnlyCache == null)
 			{
 				throw new InvalidOperationException($"Cache {cache.GetType()} does not support batching get operation");
 			}
 			if (log.IsDebugEnabled())
 			{
 				log.Debug("Cache lookup: {0}", string.Join(",", keys.AsEnumerable()));
 			}
-			var results = _batchableReadCache.GetMany(keys.Select(o => (object) o).ToArray());
+			var results = _batchableReadOnlyCache.GetMany(keys.Select(o => (object) o).ToArray());
 			if (!log.IsDebugEnabled())
 			{
 				return results;
@@ -80,7 +80,7 @@ public ISoftLock Lock(CacheKey key, object version)
 		public bool[] PutMany(CacheKey[] keys, object[] values, long timestamp, object[] versions, IComparer[] versionComparers,
 		                          bool[] minimalPuts)
 		{
-			if (_batchableReadWriteCache == null)
+			if (_batchableCache == null)
 			{
 				throw new InvalidOperationException($"Cache {cache.GetType()} does not support batching operations");
 			}
@@ -104,7 +104,7 @@ public bool[] PutMany(CacheKey[] keys, object[] values, long timestamp, object[]
 			var skipKeyIndexes = new HashSet<int>();
 			if (checkKeys.Any())
 			{
-				var objects = _batchableReadWriteCache.GetMany(checkKeys.Select(o => (object) o).ToArray());
+				var objects = _batchableCache.GetMany(checkKeys.Select(o => (object) o).ToArray());
 				for (var i = 0; i < objects.Length; i++)
 				{
 					if (objects[i] != null)
@@ -136,7 +136,7 @@ public bool[] PutMany(CacheKey[] keys, object[] values, long timestamp, object[]
 				putValues[j++] = values[i];
 				result[i] = true;
 			}
-			_batchableReadWriteCache.PutMany(putKeys, putValues);
+			_batchableCache.PutMany(putKeys, putValues);
 			return result;
 		}
 
diff --git a/src/NHibernate/Cache/ReadWriteCache.cs b/src/NHibernate/Cache/ReadWriteCache.cs
diff --git a/src/NHibernate/Cache/UpdateTimestampsCache.cs b/src/NHibernate/Cache/UpdateTimestampsCache.cs
diff --git a/src/NHibernate/Engine/BatchFetchQueue.cs b/src/NHibernate/Engine/BatchFetchQueue.cs

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@`
`19`	`19`
`20`	`20`	`namespace NHibernate.Test.CacheTest.Caches`
`21`	`21`	`{`
`22`		`- public partial class BatchableCache : ICache, IBatchableReadWriteCache`
	`22`	`+ public partial class BatchableCache : ICache, IBatchableCache`
`23`	`23`	`{`
`24`	`24`
`25`	`25`	`public Task PutManyAsync(object[] keys, object[] values, CancellationToken cancellationToken)`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@`
`9`	`9`
`10`	`10`	`namespace NHibernate.Test.CacheTest.Caches`
`11`	`11`	`{`
`12`		`- public partial class BatchableCache : ICache, IBatchableReadWriteCache`
	`12`	`+ public partial class BatchableCache : ICache, IBatchableCache`
`13`	`13`	`{`
`14`	`14`	`private readonly IDictionary _hashtable = new Hashtable();`
`15`	`15`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ namespace NHibernate.Cache`
`16`	`16`	`{`
`17`	`17`	`using System.Threading.Tasks;`
`18`	`18`	`using System.Threading;`
`19`		`- public partial interface IBatchableReadWriteCache : IBatchableReadCache`
	`19`	`+ public partial interface IBatchableCache : IBatchableReadOnlyCache`
`20`	`20`	`{`
`21`	`21`	`/// <summary>`
`22`	`22`	`/// Add multiple objects to the cache.`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ public async Task<object> GetAsync(CacheKey key, long txTimestamp, CancellationT`
`46`	`46`
`47`	`47`	`public Task<object[]> GetManyAsync(CacheKey[] keys, long timestamp, CancellationToken cancellationToken)`
`48`	`48`	`{`
`49`		`- if (_batchableReadCache == null)`
	`49`	`+ if (_batchableReadOnlyCache == null)`
`50`	`50`	`{`
`51`	`51`	`throw new InvalidOperationException($"Cache {cache.GetType()} does not support batching get operation");`
`52`	`52`	`}`
`@@ -61,7 +61,7 @@ async Task<object[]> InternalGetManyAsync()`
`61`	`61`	`{`
`62`	`62`	`log.Debug("Cache lookup: {0}", string.Join(",", keys.AsEnumerable()));`
`63`	`63`	`}`
`64`		`- var results = await (_batchableReadCache.GetManyAsync(keys.Select(o => (object) o).ToArray(), cancellationToken)).ConfigureAwait(false);`
	`64`	`+ var results = await (_batchableReadOnlyCache.GetManyAsync(keys.Select(o => (object) o).ToArray(), cancellationToken)).ConfigureAwait(false);`
`65`	`65`	`if (!log.IsDebugEnabled())`
`66`	`66`	`{`
`67`	`67`	`return results;`
`@@ -80,7 +80,7 @@ async Task<object[]> InternalGetManyAsync()`
`80`	`80`	`public Task<bool[]> PutManyAsync(CacheKey[] keys, object[] values, long timestamp, object[] versions, IComparer[] versionComparers,`
`81`	`81`	`bool[] minimalPuts, CancellationToken cancellationToken)`
`82`	`82`	`{`
`83`		`- if (_batchableReadWriteCache == null)`
	`83`	`+ if (_batchableCache == null)`
`84`	`84`	`{`
`85`	`85`	`throw new InvalidOperationException($"Cache {cache.GetType()} does not support batching operations");`
`86`	`86`	`}`
`@@ -111,7 +111,7 @@ async Task<bool[]> InternalPutManyAsync()`
`111`	`111`	`var skipKeyIndexes = new HashSet<int>();`
`112`	`112`	`if (checkKeys.Any())`
`113`	`113`	`{`
`114`		`- var objects = await (_batchableReadWriteCache.GetManyAsync(checkKeys.ToArray(), cancellationToken)).ConfigureAwait(false);`
	`114`	`+ var objects = await (_batchableCache.GetManyAsync(checkKeys.ToArray(), cancellationToken)).ConfigureAwait(false);`
`115`	`115`	`for (var i = 0; i < objects.Length; i++)`
`116`	`116`	`{`
`117`	`117`	`if (objects[i] != null)`
`@@ -143,7 +143,7 @@ async Task<bool[]> InternalPutManyAsync()`
`143`	`143`	`putValues[j++] = values[i];`
`144`	`144`	`result[i] = true;`
`145`	`145`	`}`
`146`		`- await (_batchableReadWriteCache.PutManyAsync(putKeys, putValues, cancellationToken)).ConfigureAwait(false);`
	`146`	`+ await (_batchableCache.PutManyAsync(putKeys, putValues, cancellationToken)).ConfigureAwait(false);`
`147`	`147`	`return result;`
`148`	`148`	`}`
`149`	`149`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ public async Task<object> GetAsync(CacheKey key, long timestamp, CancellationTok`
`34`	`34`
`35`	`35`	`public Task<object[]> GetManyAsync(CacheKey[] keys, long timestamp, CancellationToken cancellationToken)`
`36`	`36`	`{`
`37`		`- if (_batchableReadCache == null)`
	`37`	`+ if (_batchableReadOnlyCache == null)`
`38`	`38`	`{`
`39`	`39`	`throw new InvalidOperationException($"Cache {cache.GetType()} does not support batching get operation");`
`40`	`40`	`}`
`@@ -49,7 +49,7 @@ async Task<object[]> InternalGetManyAsync()`
`49`	`49`	`{`
`50`	`50`	`log.Debug("Cache lookup: {0}", string.Join(",", keys.AsEnumerable()));`
`51`	`51`	`}`
`52`		`- var results = await (_batchableReadCache.GetManyAsync(keys.Select(o => (object) o).ToArray(), cancellationToken)).ConfigureAwait(false);`
	`52`	`+ var results = await (_batchableReadOnlyCache.GetManyAsync(keys.Select(o => (object) o).ToArray(), cancellationToken)).ConfigureAwait(false);`
`53`	`53`	`if (!log.IsDebugEnabled())`
`54`	`54`	`{`
`55`	`55`	`return results;`
`@@ -84,7 +84,7 @@ public Task<ISoftLock> LockAsync(CacheKey key, object version, CancellationToken`
`84`	`84`	`public Task<bool[]> PutManyAsync(CacheKey[] keys, object[] values, long timestamp, object[] versions, IComparer[] versionComparers,`
`85`	`85`	`bool[] minimalPuts, CancellationToken cancellationToken)`
`86`	`86`	`{`
`87`		`- if (_batchableReadWriteCache == null)`
	`87`	`+ if (_batchableCache == null)`
`88`	`88`	`{`
`89`	`89`	`throw new InvalidOperationException($"Cache {cache.GetType()} does not support batching operations");`
`90`	`90`	`}`
`@@ -115,7 +115,7 @@ async Task<bool[]> InternalPutManyAsync()`
`115`	`115`	`var skipKeyIndexes = new HashSet<int>();`
`116`	`116`	`if (checkKeys.Any())`
`117`	`117`	`{`
`118`		`- var objects = await (_batchableReadWriteCache.GetManyAsync(checkKeys.Select(o => (object) o).ToArray(), cancellationToken)).ConfigureAwait(false);`
	`118`	`+ var objects = await (_batchableCache.GetManyAsync(checkKeys.Select(o => (object) o).ToArray(), cancellationToken)).ConfigureAwait(false);`
`119`	`119`	`for (var i = 0; i < objects.Length; i++)`
`120`	`120`	`{`
`121`	`121`	`if (objects[i] != null)`
`@@ -147,7 +147,7 @@ async Task<bool[]> InternalPutManyAsync()`
`147`	`147`	`putValues[j++] = values[i];`
`148`	`148`	`result[i] = true;`
`149`	`149`	`}`
`150`		`- await (_batchableReadWriteCache.PutManyAsync(putKeys, putValues, cancellationToken)).ConfigureAwait(false);`
	`150`	`+ await (_batchableCache.PutManyAsync(putKeys, putValues, cancellationToken)).ConfigureAwait(false);`
`151`	`151`	`return result;`
`152`	`152`	`}`
`153`	`153`	`}`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ public async Task<object> GetAsync(CacheKey key, long txTimestamp, CancellationT`
`92`	`92`
`93`	`93`	`public Task<object[]> GetManyAsync(CacheKey[] keys, long timestamp, CancellationToken cancellationToken)`
`94`	`94`	`{`
`95`		`- if (_batchableReadCache == null)`
	`95`	`+ if (_batchableReadOnlyCache == null)`
`96`	`96`	`{`
`97`	`97`	`throw new InvalidOperationException($"Cache {cache.GetType()} does not support batching get operation");`
`98`	`98`	`}`
`@@ -110,7 +110,7 @@ async Task<object[]> InternalGetManyAsync()`
`110`	`110`	`var result = new object[keys.Length];`
`111`	`111`	`using (await _lockObjectAsync.LockAsync())`
`112`	`112`	`{`
`113`		`- var lockables = await (_batchableReadCache.GetManyAsync(keys.Select(o => (object) o).ToArray(), cancellationToken)).ConfigureAwait(false);`
	`113`	`+ var lockables = await (_batchableReadOnlyCache.GetManyAsync(keys.Select(o => (object) o).ToArray(), cancellationToken)).ConfigureAwait(false);`
`114`	`114`	`for (var i = 0; i < lockables.Length; i++)`
`115`	`115`	`{`
`116`	`116`	`var lockable = (ILockable) lockables[i];`
`@@ -183,7 +183,7 @@ public async Task<ISoftLock> LockAsync(CacheKey key, object version, Cancellatio`
`183`	`183`	`public Task<bool[]> PutManyAsync(CacheKey[] keys, object[] values, long timestamp, object[] versions, IComparer[] versionComparers,`
`184`	`184`	`bool[] minimalPuts, CancellationToken cancellationToken)`
`185`	`185`	`{`
`186`		`- if (_batchableReadWriteCache == null)`
	`186`	`+ if (_batchableCache == null)`
`187`	`187`	`{`
`188`	`188`	`throw new InvalidOperationException($"Cache {cache.GetType()} does not support batching operations");`
`189`	`189`	`}`
`@@ -211,9 +211,9 @@ async Task<bool[]> InternalPutManyAsync()`
`211`	`211`	`var keysArr = keys.Cast<object>().ToArray();`
`212`	`212`	`try`
`213`	`213`	`{`
`214`		`- await (_batchableReadWriteCache.LockManyAsync(keysArr, cancellationToken)).ConfigureAwait(false);`
	`214`	`+ await (_batchableCache.LockManyAsync(keysArr, cancellationToken)).ConfigureAwait(false);`
`215`	`215`	`var putBatch = new Dictionary<object, object>();`
`216`		`- var lockables = await (_batchableReadWriteCache.GetManyAsync(keysArr, cancellationToken)).ConfigureAwait(false);`
	`216`	`+ var lockables = await (_batchableCache.GetManyAsync(keysArr, cancellationToken)).ConfigureAwait(false);`
`217`	`217`	`for (var i = 0; i < keys.Length; i++)`
`218`	`218`	`{`
`219`	`219`	`var key = keys[i];`
`@@ -249,12 +249,12 @@ async Task<bool[]> InternalPutManyAsync()`
`249`	`249`
`250`	`250`	`if (putBatch.Count > 0)`
`251`	`251`	`{`
`252`		`- await (_batchableReadWriteCache.PutManyAsync(putBatch.Keys.ToArray(), putBatch.Values.ToArray(), cancellationToken)).ConfigureAwait(false);`
	`252`	`+ await (_batchableCache.PutManyAsync(putBatch.Keys.ToArray(), putBatch.Values.ToArray(), cancellationToken)).ConfigureAwait(false);`
`253`	`253`	`}`
`254`	`254`	`}`
`255`	`255`	`finally`
`256`	`256`	`{`
`257`		`- await (_batchableReadWriteCache.UnlockManyAsync(keysArr, cancellationToken)).ConfigureAwait(false);`
	`257`	`+ await (_batchableCache.UnlockManyAsync(keysArr, cancellationToken)).ConfigureAwait(false);`
`258`	`258`	`}`
`259`	`259`	`}`
`260`	`260`	`return result;`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ namespace NHibernate.Cache`
`15`	`15`	`/// All implementations <em>must</em> be threadsafe.`
`16`	`16`	`/// </para>`
`17`	`17`	`/// </remarks>`
`18`		`- public partial interface IBatchableReadWriteCache : IBatchableReadCache`
	`18`	`+ public partial interface IBatchableCache : IBatchableReadOnlyCache`
`19`	`19`	`{`
`20`	`20`	`/// <summary>`
`21`	`21`	`/// Add multiple objects to the cache.`