Port Hibernate's BytecodeEnhancementMetadata

Author: maca88

src/NHibernate/Async/Event/Default/DefaultMergeEventListener.cs

@@ -389,7 +389,7 @@ protected virtual async Task EntityIsDetachedAsync(MergeEvent @event, IDictionar
 				await (CopyValuesAsync(persister, entity, target, source, copyCache, cancellationToken)).ConfigureAwait(false);
 
 				//copyValues works by reflection, so explicitly mark the entity instance dirty
-				MarkInterceptorDirty(entity, target);
+				MarkInterceptorDirty(entity, persister, target);
 
 				@event.Result = result;
 			}

src/NHibernate/Async/Persister/Entity/AbstractEntityPersister.cs

@@ -36,6 +36,7 @@
 using Property=NHibernate.Mapping.Property;
 using NHibernate.SqlTypes;
 using System.Linq;
+using NHibernate.Bytecode;
 
 namespace NHibernate.Persister.Entity
 {

src/NHibernate/Bytecode/IBytecodeEnhancementMetadata.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using NHibernate.Engine;
+using NHibernate.Intercept;
+using NHibernate.Tuple.Entity;
+
+namespace NHibernate.Bytecode
+{
+	/// <summary>
+	/// Encapsulates bytecode enhancement information about a particular entity.
+	/// 
+	/// Author: Steve Ebersole
+	/// </summary>
+	public interface IBytecodeEnhancementMetadata
+	{
+		/// <summary>
+		/// The name of the entity to which this metadata applies.
+		/// </summary>
+		string EntityName { get; }
+
+		/// <summary>
+		/// Has the entity class been bytecode enhanced for lazy loading?
+		/// </summary>
+		bool EnhancedForLazyLoading { get; }
+
+		LazyPropertiesMetadata LazyPropertiesMetadata { get; }
+
+		/// <summary>
+		/// Build and inject an interceptor instance into the enhanced entity.
+		/// </summary>
+		/// <param name="entity">The entity into which built interceptor should be injected.</param>
+		/// <param name="lazyPropertiesAreUnfetched">Whether all lazy properties were unfetched or not.</param>
+		/// <param name="session">The session to which the entity instance belongs.</param>
+		/// <returns>The built and injected interceptor.</returns>
+		// TODO: Remove lazyPropertiesAreUnfetched when interceptor will be injected on entity instantiation
+		IFieldInterceptor InjectInterceptor(object entity, bool lazyPropertiesAreUnfetched, ISessionImplementor session);
+
+		/// <summary>
+		/// Extract the field interceptor instance from the enhanced entity.
+		/// </summary>
+		/// <param name="entity">The entity from which to extract the interceptor.</param>
+		/// <returns>The extracted interceptor.</returns>
+		IFieldInterceptor ExtractInterceptor(object entity);
+
+		/// <summary>
+		/// Retrieve the uninitialized lazy properties from the enhanced entity.
+		/// </summary>
+		/// <param name="entity">The entity from which to retrieve the uninitialized lazy properties.</param>
+		/// <returns></returns>
+		ISet<string> GetUninitializedLazyProperties(object entity);
+
+		/// <summary>
+		/// Retrieve the uninitialized lazy properties from the entity state.
+		/// </summary>
+		/// <param name="entityState">The entity state from which to retrieve the uninitialized lazy properties.</param>
+		/// <returns></returns>
+		ISet<string> GetUninitializedLazyProperties(object[] entityState);
+	}
+}

src/NHibernate/Bytecode/LazyPropertiesMetadata.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Iesi.Collections.Generic;
+using NHibernate.Util;
+
+namespace NHibernate.Bytecode
+{
+	/// <summary>
+	/// Information about all of the bytecode lazy properties for an entity
+	/// 
+	/// Author: Steve Ebersole
+	/// </summary>
+	[Serializable]
+	public class LazyPropertiesMetadata
+	{
+		public static LazyPropertiesMetadata NonEnhanced(string entityName)
+		{
+			return new LazyPropertiesMetadata(entityName, null, null);
+		}
+
+		public static LazyPropertiesMetadata From(
+			string entityName,
+			IEnumerable<LazyPropertyDescriptor> lazyPropertyDescriptors,
+			ISet<string> unwrapProxyPropertyNames)
+		{
+			// TODO: port lazy fetch groups
+			return new LazyPropertiesMetadata(
+				entityName,
+				lazyPropertyDescriptors.ToDictionary(o => o.Name),
+				unwrapProxyPropertyNames);
+		}
+
+		private readonly IDictionary<string, LazyPropertyDescriptor> _lazyPropertyDescriptors;
+
+		public LazyPropertiesMetadata(
+			string entityName,
+			IDictionary<string, LazyPropertyDescriptor> lazyPropertyDescriptors,
+			ISet<string> unwrapProxyPropertyNames)
+		{
+			EntityName = entityName;
+			_lazyPropertyDescriptors = lazyPropertyDescriptors;
+			HasLazyProperties = _lazyPropertyDescriptors?.Count > 0;
+			LazyPropertyNames = HasLazyProperties
+				? new ReadOnlySet<string>(new HashSet<string>(_lazyPropertyDescriptors.Keys))
+				: CollectionHelper.EmptySet<string>();
+			HasUnwrapProxyProperties = unwrapProxyPropertyNames?.Count > 0;
+			UnwrapProxyPropertyNames = HasUnwrapProxyProperties
+				? new ReadOnlySet<string>(unwrapProxyPropertyNames)
+				: CollectionHelper.EmptySet<string>();
+			// TODO: port lazy fetch groups
+		}
+
+		public string EntityName { get; }
+
+		public bool HasLazyProperties { get; }
+
+		public bool HasUnwrapProxyProperties { get; }
+
+		public ISet<string> LazyPropertyNames { get; }
+
+		public ISet<string> UnwrapProxyPropertyNames { get; }
+
+		public IEnumerable<LazyPropertyDescriptor> LazyPropertyDescriptors =>
+			_lazyPropertyDescriptors?.Values ?? Enumerable.Empty<LazyPropertyDescriptor>();
+	}
+}

src/NHibernate/Bytecode/LazyPropertyDescriptor.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using NHibernate.Type;
+
+namespace NHibernate.Bytecode
+{
+	/// <summary>
+	/// Descriptor for a property which is enabled for bytecode lazy fetching
+	///
+	/// Author: Steve Ebersole
+	/// </summary>
+	public class LazyPropertyDescriptor
+	{
+		public static LazyPropertyDescriptor From(
+			Mapping.Property property,
+			int attributeIndex,
+			int lazyIndex)
+		{
+			// TODO: port lazy fetch groups
+
+			return new LazyPropertyDescriptor(
+				attributeIndex,
+				lazyIndex,
+				property.Name,
+				property.Type
+			);
+		}
+
+		private LazyPropertyDescriptor(
+			int propertyIndex,
+			int lazyIndex,
+			string name,
+			IType type)
+		{
+			if (propertyIndex < lazyIndex)
+			{
+				throw new InvalidOperationException("Property index is lower than the lazy index.");
+			}
+
+			PropertyIndex = propertyIndex;
+			LazyIndex = lazyIndex;
+			Name = name;
+			Type = type;
+		}
+
+		/// <summary>
+		/// Access to the index of the property in terms of its position in the entity persister
+		/// </summary>
+		public int PropertyIndex { get; }
+
+		/// <summary>
+		/// Access to the index of the property in terms of its position within the lazy properties of the persister
+		/// </summary>
+		public int LazyIndex { get; }
+
+		/// <summary>
+		/// Access to the name of the property
+		/// </summary>
+		public string Name { get; }
+
+		/// <summary>
+		/// Access to the property's type
+		/// </summary>
+		public IType Type { get; set; }
+	}
+}

src/NHibernate/Bytecode/NotInstrumentedException.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NHibernate.Bytecode
+{
+	/// <summary>
+	/// Indicates a condition where an instrumented/enhanced class was expected, but the class was not
+	/// instrumented/enhanced.
+	/// 
+	/// Author: Steve Ebersole
+	/// </summary>
+	public class NotInstrumentedException : HibernateException
+	{
+		/// <summary>
+		/// Constructs a NotInstrumentedException.
+		/// </summary>
+		/// <param name="message">Message explaining the exception condition.</param>
+		public NotInstrumentedException(string message) : base(message)
+		{
+		}
+	}
+}

src/NHibernate/Engine/EntityEntry.cs

@@ -233,7 +233,11 @@ public void PostUpdate(object entity, object[] updatedState, object nextVersion)
 				version = nextVersion;
 				Persister.SetPropertyValue(entity, Persister.VersionProperty, nextVersion);
 			}
-			FieldInterceptionHelper.ClearDirty(entity);
+
+			if (Persister.IsInstrumented)
+			{
+				persister.ExtractFieldInterceptor(entity)?.ClearDirty();
+			}
 		}
 
 		/// <summary>
@@ -265,7 +269,7 @@ public bool RequiresDirtyCheck(object entity)
 			return
 				IsModifiableEntity()
 				&& (Persister.HasMutableProperties || !FieldInterceptionHelper.IsInstrumented(entity)
-				|| FieldInterceptionHelper.ExtractFieldInterceptor(entity).IsDirty);
+				|| Persister.ExtractFieldInterceptor(entity).IsDirty);
 		}
 
 		/// <summary>

src/NHibernate/Event/Default/AbstractSaveEventListener.cs

@@ -301,7 +301,7 @@ private void MarkInterceptorDirty(object entity, IEntityPersister persister, IEv
 		{
 			if (FieldInterceptionHelper.IsInstrumented(entity))
 			{
-				IFieldInterceptor interceptor = FieldInterceptionHelper.InjectFieldInterceptor(entity, persister.EntityName, persister.MappedClass, null, null, source);
+				var interceptor = persister.InjectFieldInterceptor(entity, null, null, source);
 				interceptor.MarkDirty();
 			}
 		}

src/NHibernate/Event/Default/DefaultMergeEventListener.cs

@@ -380,7 +380,7 @@ protected virtual void EntityIsDetached(MergeEvent @event, IDictionary copyCache
 				CopyValues(persister, entity, target, source, copyCache);
 
 				//copyValues works by reflection, so explicitly mark the entity instance dirty
-				MarkInterceptorDirty(entity, target);
+				MarkInterceptorDirty(entity, persister, target);
 
 				@event.Result = result;
 			}
@@ -400,11 +400,11 @@ protected virtual bool InvokeUpdateLifecycle(object entity, IEntityPersister per
 			return false;
 		}
 
-		private void MarkInterceptorDirty(object entity, object target)
+		private void MarkInterceptorDirty(object entity, IEntityPersister persister, object target)
 		{
-			if (FieldInterceptionHelper.IsInstrumented(entity))
+			if (persister.IsInstrumented)
 			{
-				IFieldInterceptor interceptor = FieldInterceptionHelper.ExtractFieldInterceptor(target);
+				var interceptor = persister.ExtractFieldInterceptor(target);
 				if (interceptor != null)
 				{
 					interceptor.MarkDirty();

src/NHibernate/Impl/SessionImpl.cs

@@ -958,10 +958,11 @@ public override string BestGuessEntityName(object entity)
 					}
 					entity = initializer.GetImplementation();
 				}
-				if (FieldInterceptionHelper.IsInstrumented(entity))
+
+				var interceptor = FieldInterceptionHelper.ExtractFieldInterceptor(entity);
+				if (interceptor != null)
 				{
 					// NH: support of field-interceptor-proxy
-					IFieldInterceptor interceptor = FieldInterceptionHelper.ExtractFieldInterceptor(entity);
 					return interceptor.EntityName;
 				}
 				EntityEntry entry = persistenceContext.GetEntry(entity);

src/NHibernate/Intercept/FieldInterceptionHelper.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using NHibernate.Engine;
 
@@ -32,6 +33,7 @@ public static IFieldInterceptor ExtractFieldInterceptor(object entity)
 			return fieldInterceptorAccessor == null ? null : fieldInterceptorAccessor.FieldInterceptor;
 		}
 
+		[Obsolete("Use IBytecodeEnhancementMetadata.InjectInterceptor method instead")]
 		public static IFieldInterceptor InjectFieldInterceptor(object entity, string entityName, 
 			System.Type mappedClass,
 			ISet<string> uninitializedFieldNames, 
@@ -48,6 +50,7 @@ public static IFieldInterceptor InjectFieldInterceptor(object entity, string ent
 			return null;
 		}
 
+		[Obsolete("This method has no more usages and will be removed in a future version")]
 		public static void ClearDirty(object entity)
 		{
 			IFieldInterceptor interceptor = ExtractFieldInterceptor(entity);
@@ -57,6 +60,7 @@ public static void ClearDirty(object entity)
 			}
 		}
 
+		[Obsolete("This method has no more usages and will be removed in a future version")]
 		public static void MarkDirty(object entity)
 		{
 			IFieldInterceptor interceptor = ExtractFieldInterceptor(entity);
@@ -66,4 +70,4 @@ public static void MarkDirty(object entity)
 			}
 		}
 	}
-}
+}