- Update to NHibernate 3.1.0

- NHibernate helper

git-svn-id: https://nhcontrib.svn.sourceforge.net/svnroot/nhcontrib/trunk@1662 d7b3437e-3345-0410-94a8-cbd290e69f67

src/NHibernate.Validator/lib/nhibernate-mapping.xsd

@@ -1342,6 +1342,7 @@
 					<xs:element ref="one-to-one" />
 					<xs:element ref="component" />
 					<xs:element ref="dynamic-component" />
+					<xs:element ref="properties" />
 					<xs:element ref="any" />
 					<xs:element ref="map" />
 					<xs:element ref="set" />

src/NHibernate.Validator/src/NHibernate.Validator.Tests/DeepIntegration/AbstractMultipleCollectionFixture.cs

@@ -2,6 +2,7 @@
 using NHibernate.Validator.Cfg;
 using NHibernate.Validator.Engine;
 using NHibernate.Validator.Event;
+using NHibernate.Validator.Util;
 using NUnit.Framework;
 using System.Collections.Generic;
 
@@ -80,13 +81,13 @@ public void NoInitializeAfterFetch()
 
 				// This two lines are not needed for tests because is a NH matter
 				// we use it only to check where the problem really is
-				Assert.IsFalse(NHibernateUtil.IsInitialized(p.Children));
-				Assert.IsFalse(NHibernateUtil.IsInitialized(p.Friends));
+				Assert.IsFalse(NHibernateHelper.IsInitialized(p.Children));
+				Assert.IsFalse(NHibernateHelper.IsInitialized(p.Friends));
 
 				vengine.Validate(p);
 
-				Assert.IsFalse(NHibernateUtil.IsInitialized(p.Children));
-				Assert.IsFalse(NHibernateUtil.IsInitialized(p.Friends));
+				Assert.IsFalse(NHibernateHelper.IsInitialized(p.Children));
+				Assert.IsFalse(NHibernateHelper.IsInitialized(p.Friends));
 			}
 
 			// No initialized many-to-one
@@ -97,23 +98,23 @@ public void NoInitializeAfterFetch()
 
 				// This line are not needed for tests because is a NH matter
 				// we use it only to check where the problem really is
-				Assert.IsFalse(NHibernateUtil.IsInitialized(p.Parent));
+				Assert.IsFalse(NHibernateHelper.IsInitialized(p.Parent));
 
 				vengine.Validate(p);
 
-				Assert.IsFalse(NHibernateUtil.IsInitialized(p.Parent));
+				Assert.IsFalse(NHibernateHelper.IsInitialized(p.Parent));
 			}
 
 			// No initialized the proxie it self
 			using (ISession s = OpenSession())
 			{
 				Person p = s.Load<Person>(savedId);
 
-				Assert.IsFalse(NHibernateUtil.IsInitialized(p));
+				Assert.IsFalse(NHibernateHelper.IsInitialized(p));
 
 				vengine.Validate(p);
 
-				Assert.IsFalse(NHibernateUtil.IsInitialized(p));
+				Assert.IsFalse(NHibernateHelper.IsInitialized(p));
 			}
 
 			CleanUp();

src/NHibernate.Validator/src/NHibernate.Validator.Tests/Integration/DefaultEntityTypeInspectorFixture.cs

@@ -1,5 +1,6 @@
 using System.Collections;
 using NHibernate.Validator.Engine;
+using NHibernate.Validator.Util;
 using NUnit.Framework;
 
 namespace NHibernate.Validator.Tests.Integration
@@ -30,7 +31,7 @@ public void ReturnTheCorrectType()
 			}
 			var ei = new DefaultEntityTypeInspector();
 			Assert.That(ei.GuessType(proxy), Is.EqualTo(typeof (AnEntity)));
-			Assert.That(!NHibernateUtil.IsInitialized(proxy), "should not initialize the proxy");
+			Assert.That(!NHibernateHelper.IsInitialized(proxy), "should not initialize the proxy");
 		}
 	}
 }

src/NHibernate.Validator/src/NHibernate.Validator.Tests/Integration/ValidatingProxyFixture.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using NHibernate.Validator.Cfg.Loquacious;
 using NHibernate.Validator.Engine;
+using NHibernate.Validator.Util;
 using NUnit.Framework;
 
 namespace NHibernate.Validator.Tests.Integration
@@ -74,7 +75,7 @@ public void ValidateNotInitializeProxyAtFirstLevel()
 				var proxy = s.Load<SimpleWithRelation>(savedId);
 				Assert.That(engine.IsValid(proxy));
 				Assert.DoesNotThrow(() => engine.AssertValid(proxy));
-				Assert.That(!NHibernateUtil.IsInitialized(proxy), "should not initialize the proxy");
+				Assert.That(!NHibernateHelper.IsInitialized(proxy), "should not initialize the proxy");
 			}
 
 			CleanDb();
@@ -238,7 +239,7 @@ public void ValidateNotInitializeProxyAtDeepLevel()
 				var proxy = s.Load<Relation>(savedIdRelation);
 				Assert.That(engine.IsValid(new SimpleWithRelation { Name = "OK", Relation = proxy }));
 				Assert.DoesNotThrow(() => engine.AssertValid(new SimpleWithRelation {Name = "OK", Relation = proxy}));
-				Assert.That(!NHibernateUtil.IsInitialized(proxy), "should not initialize the proxy");
+				Assert.That(!NHibernateHelper.IsInitialized(proxy), "should not initialize the proxy");
 			}
 
 			CleanDb();

src/NHibernate.Validator/src/NHibernate.Validator/Engine/ClassValidator.cs

@@ -285,19 +285,19 @@ private IEnumerable<InvalidValue> GetInvalidValues(object entity, HashSet<object
 		private IEnumerable<InvalidValue> GetChildrenInvalidValues(object entity, string memberName, HashSet<object> circularityState, ICollection<object> activeTags)
 		{
 			return from member in childGetters
-				   where memberName.Equals(member.Name) && NHibernateUtil.IsPropertyInitialized(entity, member.Name)
+				   where memberName.Equals(member.Name) && NHibernateHelper.IsPropertyInitialized(entity, member.Name)
 				   let value = TypeUtils.GetMemberValue(entity, member)
-				   where value != null && (NHibernateUtil.IsInitialized(value) || value is AbstractPersistentCollection)
+				   where value != null && (NHibernateHelper.IsInitialized(value) || value is AbstractPersistentCollection)
 				   from invalidValue in ChildInvalidValues(value, entity, member, circularityState, activeTags)
 				   select invalidValue;
 		}
 
 		private IEnumerable<InvalidValue> GetChildrenInvalidValues(object entity, HashSet<object> circularityState, ICollection<object> activeTags)
 		{
 			return from member in childGetters
-			       where NHibernateUtil.IsPropertyInitialized(entity, member.Name)
+			       where NHibernateHelper.IsPropertyInitialized(entity, member.Name)
 			       let value = TypeUtils.GetMemberValue(entity, member)
-			       where value != null && (NHibernateUtil.IsInitialized(value) || value is AbstractPersistentCollection)
+			       where value != null && (NHibernateHelper.IsInitialized(value) || value is AbstractPersistentCollection)
 			       from invalidValue in ChildInvalidValues(value, entity, member, circularityState, activeTags)
 			       select invalidValue;
 		}
@@ -328,7 +328,7 @@ private bool IsValidationNeededByTags(ICollection<object> activeTags, ICollectio
 		private IEnumerable<InvalidValue> ChildInvalidValues(object value, object entity, MemberInfo member, HashSet<object> circularityState, ICollection<object> activeTags)
 		{
 			var valueEnum = value as IEnumerable;
-			if (!NHibernateUtil.IsInitialized(value) && value is AbstractPersistentCollection)
+			if (!NHibernateHelper.IsInitialized(value) && value is AbstractPersistentCollection)
 			{
 				valueEnum = (value as AbstractPersistentCollection).QueuedAdditionIterator;
 			}
@@ -690,9 +690,9 @@ private IEnumerable<InvalidValue> MembersInvalidValues(object entity, string mem
 
 			return from mtv in membersValidators
 				   let member = mtv.Getter
-				   where NHibernateUtil.IsPropertyInitialized(entity, member.Name)
+				   where NHibernateHelper.IsPropertyInitialized(entity, member.Name)
 				   let value = TypeUtils.GetMemberValue(entity, member)
-				   where IsValidationNeededByTags(activeTags, mtv.ValidatorDef.Tags) && NHibernateUtil.IsInitialized(value)
+				   where IsValidationNeededByTags(activeTags, mtv.ValidatorDef.Tags) && NHibernateHelper.IsInitialized(value)
 				   let validator = mtv.ValidatorDef.Validator
 				   let constraintContext = new ConstraintValidatorContext(member.Name, defaultInterpolator.GetAttributeMessage(validator))
 				   where !validator.IsValid(value, constraintContext)

src/NHibernate.Validator/src/NHibernate.Validator/NHibernate.Validator.csproj

@@ -137,6 +137,7 @@
     <Compile Include="Engine\ReferenceEqualityComparer.cs" />
     <Compile Include="Engine\SystemTypeExtensions.cs" />
     <Compile Include="Event\ValidatePreCollectionUpdateEventListener.cs" />
+    <Compile Include="Util\NHibernateHelper.cs" />
     <Compile Include="Util\EnumerableExtensions.cs" />
     <Compile Include="Constraints\IsNumericAttribute.cs" />
     <Compile Include="Constraints\WithinAttribute.cs" />

src/NHibernate.Validator/src/NHibernate.Validator/Util/NHibernateHelper.cs

@@ -0,0 +1,82 @@
+using NHibernate.Bytecode;
+using NHibernate.Collection;
+using NHibernate.Intercept;
+using NHibernate.Proxy;
+
+namespace NHibernate.Validator.Util
+{
+	/// <summary>
+	/// Ported from NHibernate with changes
+	/// </summary>
+	public class NHibernateHelper
+	{
+		public static bool IsPropertyInitialized(object proxy, string propertyName)
+		{
+			object entity;
+
+			if (!IsProxyFactoryConfigurated())
+			{
+				//if the proxy provider it's not configurated, can't be a proxy neither an instrumented field.
+				return true;
+			}
+
+			if (proxy.IsProxy())
+			{
+				ILazyInitializer li = ((INHibernateProxy)proxy).HibernateLazyInitializer;
+				if (li.IsUninitialized)
+				{
+					return false;
+				}
+				else
+				{
+					entity = li.GetImplementation();
+				}
+			}
+			else
+			{
+				entity = proxy;
+			}
+
+			if (FieldInterceptionHelper.IsInstrumented(entity))
+			{
+				IFieldInterceptor interceptor = FieldInterceptionHelper.ExtractFieldInterceptor(entity);
+				return interceptor == null || interceptor.IsInitializedField(propertyName);
+			}
+			else
+			{
+				return true;
+			}
+		}
+
+		public static bool IsInitialized(object proxy)
+		{
+			var noProxyFactory = IsProxyFactoryConfigurated();
+
+			if (noProxyFactory && proxy.IsProxy())
+			{
+				return !((INHibernateProxy)proxy).HibernateLazyInitializer.IsUninitialized;
+			}
+			else if (proxy is IPersistentCollection)
+			{
+				return ((IPersistentCollection)proxy).WasInitialized;
+			}
+			else
+			{
+				return true;
+			}
+		}
+
+		public static bool IsProxyFactoryConfigurated()
+		{
+			try
+			{
+				var f = NHibernate.Cfg.Environment.BytecodeProvider.ProxyFactoryFactory;
+				return true;
+			}
+			catch (ProxyFactoryFactoryNotConfiguredException)
+			{
+				return false;
+			}
+		}
+	}
+}