nhibernate-commit — CVS Commits

[Nhibernate-commit] SF.net SVN: nhibernate:[5803] trunk/nhibernate/releasenotes.txt

[<fab...@us...>]

Revision: 5803
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5803&view=rev
Author:   fabiomaulo
Date:     2011-05-09 16:05:57 +0000 (Mon, 09 May 2011)

Log Message:
-----------
Going to release

Modified Paths:
--------------
    trunk/nhibernate/releasenotes.txt

Modified: trunk/nhibernate/releasenotes.txt
===================================================================
--- trunk/nhibernate/releasenotes.txt	2011-05-09 16:00:11 UTC (rev 5802)
+++ trunk/nhibernate/releasenotes.txt	2011-05-09 16:05:57 UTC (rev 5803)
@@ -10,6 +10,35 @@
 		* For users who don't look at Log-ERROR, to prevent wrong behavior when lazy-properties are used the DynamicProxyValidator validates the accessability of properties setters.
 		* For those implementing IDrive without inherit from DriveBase: IDrive.AdjustCommand
 
+Build 3.2.0.Aplha3 (rev5803)
+=============================
+** Sub-task
+    * [NH-1344] - QueryTranslator: Invalid Cast to object array when using IResultTransformer
+    * [NH-1642] - one-to-many collection doesn't work if the child is mapped using table per class
+
+** Bug
+    * [NH-1090] - Query cache does not work when using Criteria API to create a projection query with a result transformer
+    * [NH-1747] - Lazy load failure on items using <join> if FK for bag is in the secondary table
+    * [NH-2510] - Lazy-loading doesn't work with cache
+    * [NH-2569] - IDGeneratorBinding seems broken when mixing schemas
+    * [NH-2587] - .Cacheable().Fetch() throws 'Exception occurred getter of xxx'
+    * [NH-2661] - NHibernate cannot handle SQL Server TIME columns when built with the .NET 4 framework
+    * [NH-2673] - Nhibernate 2nd level cache and Result transformer
+    * [NH-2685] - Unnecessary proxy initialisation in CriteriaQueryTranslator
+    * [NH-2686] - Embedded ResultsTransformers should implements Equals/GetHashCode
+
+** Improvement
+    * [NH-2505] - Querries with WHERE containing SQL Server 'bit' datatype produce CASE construction
+    * [NH-2551] - Bad code practice. Function SessionFactoryImpl.GetImplementors: if type not found - value from ReflectHelper.ClassForFullName returns through TypeLoadException.
+    * [NH-2670] - Stateless Session load no-lazy collection
+    * [NH-2684] - More simple way to add NamedQueries by-code
+
+** New Feature
+    * [NH-2674] - QueryOver doesn't have support for entity-name
+
+** Patch
+    * [NH-2669] - Patch to prevent "NHibernate.AssertionFailure: possible non-threadsafe access to the session" error caused by stateless sessions
+
 Build 3.2.0.Aplha2 (rev5715)
 =============================
 ** Bug


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5802] trunk/nhibernate/src/NHibernate

[<fab...@us...>]

Revision: 5802
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5802&view=rev
Author:   fabiomaulo
Date:     2011-05-09 16:00:11 +0000 (Mon, 09 May 2011)

Log Message:
-----------
Fix NH-2684

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Cfg/ConfigurationExtensions.cs
    trunk/nhibernate/src/NHibernate/NHibernate.csproj
    trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj

Added Paths:
-----------
    trunk/nhibernate/src/NHibernate/Cfg/Loquacious/INamedQueryDefinitionBuilder.cs
    trunk/nhibernate/src/NHibernate.Test/CfgTest/Loquacious/NamedQueryTests.cs

Modified: trunk/nhibernate/src/NHibernate/Cfg/ConfigurationExtensions.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Cfg/ConfigurationExtensions.cs	2011-05-09 14:14:11 UTC (rev 5801)
+++ trunk/nhibernate/src/NHibernate/Cfg/ConfigurationExtensions.cs	2011-05-09 16:00:11 UTC (rev 5802)
@@ -1,6 +1,7 @@
 using System;
 using NHibernate.Cfg.Loquacious;
 using NHibernate.Context;
+using NHibernate.Engine;
 using NHibernate.Hql;
 using NHibernate.Linq.Functions;
 using NHibernate.Util;
@@ -136,6 +137,26 @@
 			return configuration;
 		}
 
+		public static Configuration AddNamedQuery(this Configuration configuration, string queryIdentifier, Action<INamedQueryDefinitionBuilder> namedQueryDefinition)
+		{
+			if (configuration == null)
+			{
+				throw new ArgumentNullException("configuration");
+			}
+			if (queryIdentifier == null)
+			{
+				throw new ArgumentNullException("queryIdentifier");
+			}
+			if (namedQueryDefinition == null)
+			{
+				throw new ArgumentNullException("namedQueryDefinition");
+			}
+			var builder = new NamedQueryDefinitionBuilder();
+			namedQueryDefinition(builder);
+			configuration.NamedQueries.Add(queryIdentifier, builder.Build());
+			return configuration;
+		}
+
 		private static Mappings GetMappings(Configuration configuration)
 		{
 			Dialect.Dialect dialect = Dialect.Dialect.GetDialect(configuration.Properties);

Added: trunk/nhibernate/src/NHibernate/Cfg/Loquacious/INamedQueryDefinitionBuilder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Cfg/Loquacious/INamedQueryDefinitionBuilder.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate/Cfg/Loquacious/INamedQueryDefinitionBuilder.cs	2011-05-09 16:00:11 UTC (rev 5802)
@@ -0,0 +1,79 @@
+using System.Collections.Generic;
+using NHibernate.Engine;
+
+namespace NHibernate.Cfg.Loquacious
+{
+	public interface INamedQueryDefinitionBuilder
+	{
+		bool IsCacheable { get; set; }
+		string CacheRegion { get; set; }
+		int FetchSize { get; set; }
+		int Timeout { get; set; }
+		FlushMode FlushMode { get; set; }
+		string Query { get; set; }
+		bool IsReadOnly { get; set; }
+		string Comment { get; set; }
+		CacheMode? CacheMode { get; set; }
+	}
+
+	internal class NamedQueryDefinitionBuilder : INamedQueryDefinitionBuilder
+	{
+		private int fetchSize = -1;
+		private int timeout = -1;
+
+		public NamedQueryDefinitionBuilder()
+		{
+			FlushMode = FlushMode.Unspecified;
+		}
+
+		#region INamedQueryDefinitionBuilder Members
+
+		public bool IsCacheable { get; set; }
+		public string CacheRegion { get; set; }
+
+		public int FetchSize
+		{
+			get { return fetchSize; }
+			set
+			{
+				if (value > 0)
+				{
+					fetchSize = value;
+				}
+				else
+				{
+					fetchSize = -1;
+				}
+			}
+		}
+
+		public int Timeout
+		{
+			get { return timeout; }
+			set
+			{
+				if (value > 0)
+				{
+					timeout = value;
+				}
+				else
+				{
+					timeout = -1;
+				}
+			}
+		}
+
+		public FlushMode FlushMode { get; set; }
+		public string Query { get; set; }
+		public bool IsReadOnly { get; set; }
+		public string Comment { get; set; }
+		public CacheMode? CacheMode { get; set; }
+
+		#endregion
+
+		public NamedQueryDefinition Build()
+		{
+			return new NamedQueryDefinition(Query, IsCacheable, CacheRegion, Timeout, FetchSize, FlushMode, CacheMode ,IsReadOnly, Comment, new Dictionary<string, string>(1));
+		}
+	}
+}
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate/NHibernate.csproj
===================================================================
--- trunk/nhibernate/src/NHibernate/NHibernate.csproj	2011-05-09 14:14:11 UTC (rev 5801)
+++ trunk/nhibernate/src/NHibernate/NHibernate.csproj	2011-05-09 16:00:11 UTC (rev 5802)
@@ -113,6 +113,7 @@
     <Compile Include="Cache\Timestamper.cs" />
     <Compile Include="Cache\UpdateTimestampsCache.cs" />
     <Compile Include="CallbackException.cs" />
+    <Compile Include="Cfg\Loquacious\INamedQueryDefinitionBuilder.cs" />
     <Compile Include="Cfg\MappingsQueue.cs" />
     <Compile Include="Cfg\Configuration.cs" />
     <Compile Include="Cfg\ConfigurationSectionHandler.cs" />

Added: trunk/nhibernate/src/NHibernate.Test/CfgTest/Loquacious/NamedQueryTests.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/CfgTest/Loquacious/NamedQueryTests.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/CfgTest/Loquacious/NamedQueryTests.cs	2011-05-09 16:00:11 UTC (rev 5802)
@@ -0,0 +1,76 @@
+using System.Linq;
+using NHibernate.Cfg;
+using NUnit.Framework;
+using SharpTestsEx;
+
+namespace NHibernate.Test.CfgTest.Loquacious
+{
+	public class NamedQueryTests
+	{
+		[Test]
+		public void AddSimpleNamedQuery()
+		{
+			var configure = new Configuration();
+			configure.AddNamedQuery("aQuery", b =>
+			{
+				b.Query = "from System.Object o";
+			});
+
+			configure.NamedQueries.Should().Have.Count.EqualTo(1);
+			configure.NamedQueries.Keys.Single().Should().Be("aQuery");
+			configure.NamedQueries.Values.Single().Query.Should().Be("from System.Object o");
+		}
+
+		[Test]
+		public void WhenSetInvalidFetchSizeThenLeaveDefault()
+		{
+			var configure = new Configuration();
+			configure.AddNamedQuery("aQuery", b =>
+			{
+				b.Query = "from System.Object o";
+				b.FetchSize = 0;
+			});
+
+			configure.NamedQueries.Values.Single().FetchSize.Should().Be(-1);
+		}
+
+		[Test]
+		public void WhenSetValidFetchSizeThenSetValue()
+		{
+			var configure = new Configuration();
+			configure.AddNamedQuery("aQuery", b =>
+			{
+				b.Query = "from System.Object o";
+				b.FetchSize = 15;
+			});
+
+			configure.NamedQueries.Values.Single().FetchSize.Should().Be(15);
+		}
+
+		[Test]
+		public void WhenSetInvalidTimeoutThenLeaveDefault()
+		{
+			var configure = new Configuration();
+			configure.AddNamedQuery("aQuery", b =>
+			{
+				b.Query = "from System.Object o";
+				b.Timeout = 0;
+			});
+
+			configure.NamedQueries.Values.Single().Timeout.Should().Be(-1);
+		}
+
+		[Test]
+		public void WhenSetValidTimeoutThenSetValue()
+		{
+			var configure = new Configuration();
+			configure.AddNamedQuery("aQuery", b =>
+			{
+				b.Query = "from System.Object o";
+				b.Timeout = 123;
+			});
+
+			configure.NamedQueries.Values.Single().Timeout.Should().Be(123);
+		}
+	}
+}
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-05-09 14:14:11 UTC (rev 5801)
+++ trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-05-09 16:00:11 UTC (rev 5802)
@@ -151,6 +151,7 @@
     <Compile Include="CfgTest\Loquacious\EntityCacheConfigurationFixture.cs" />
     <Compile Include="CfgTest\Loquacious\EntityToCache.cs" />
     <Compile Include="CfgTest\Loquacious\LambdaConfigurationFixture.cs" />
+    <Compile Include="CfgTest\Loquacious\NamedQueryTests.cs" />
     <Compile Include="CfgTest\Loquacious\TypeDefinitionFixture.cs" />
     <Compile Include="CfgTest\MappingDocumentAggregatorTests.cs" />
     <Compile Include="CfgTest\MappingDocumentParserTests.cs" />


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5801] trunk/nhibernate/src/NHibernate

[<fab...@us...>]

Revision: 5801
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5801&view=rev
Author:   fabiomaulo
Date:     2011-05-09 14:14:11 +0000 (Mon, 09 May 2011)

Log Message:
-----------
Fix NH-2510

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Type/TypeHelper.cs
    trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj

Added Paths:
-----------
    trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2510/
    trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2510/Fixture.cs

Modified: trunk/nhibernate/src/NHibernate/Type/TypeHelper.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Type/TypeHelper.cs	2011-05-08 22:59:17 UTC (rev 5800)
+++ trunk/nhibernate/src/NHibernate/Type/TypeHelper.cs	2011-05-09 14:14:11 UTC (rev 5801)
@@ -61,10 +61,17 @@
 		/// <returns></returns>
 		public static object[] Assemble(object[] row, ICacheAssembler[] types, ISessionImplementor session, object owner)
 		{
-			object[] assembled = new object[row.Length];
+			var assembled = new object[row.Length];
 			for (int i = 0; i < row.Length; i++)
 			{
-				assembled[i] = types[i].Assemble(row[i], session, owner);
+				if (row[i] == LazyPropertyInitializer.UnfetchedProperty || row[i] == BackrefPropertyAccessor.Unknown)
+				{
+					assembled[i] = row[i];
+				}
+				else
+				{
+					assembled[i] = types[i].Assemble(row[i], session, owner);
+				}
 			}
 			return assembled;
 		}
@@ -110,10 +117,17 @@
 		public static object[] Replace(object[] original, object[] target, IType[] types, ISessionImplementor session,
 																	 object owner, IDictionary copiedAlready)
 		{
-			object[] copied = new object[original.Length];
+			var copied = new object[original.Length];
 			for (int i = 0; i < original.Length; i++)
 			{
-				copied[i] = types[i].Replace(original[i], target[i], session, owner, copiedAlready);
+				if (original[i] == LazyPropertyInitializer.UnfetchedProperty || original[i] == BackrefPropertyAccessor.Unknown)
+				{
+					copied[i] = target[i];
+				}
+				else
+				{
+					copied[i] = types[i].Replace(original[i], target[i], session, owner, copiedAlready);
+				}
 			}
 			return copied;
 		}
@@ -225,7 +239,7 @@
 			for (int i = 0; i < span; i++)
 			{
 				bool dirty =
-					// TODO H3: x[ i ] != LazyPropertyInitializer.UnfetchedProperty && //x is the "current" state
+					currentState[i] != LazyPropertyInitializer.UnfetchedProperty &&
 					properties[i].IsDirtyCheckable(anyUninitializedProperties)
 					&& properties[i].Type.IsDirty(previousState[i], currentState[i], includeColumns[i], session);
 
@@ -276,7 +290,7 @@
 			for (int i = 0; i < span; i++)
 			{
 				bool dirty =
-					// TODO H3: x[ i ] != LazyPropertyInitializer.UnfetchedProperty && //x is the "current" state
+					currentState[i] != LazyPropertyInitializer.UnfetchedProperty &&
 					properties[i].IsDirtyCheckable(anyUninitializedProperties)
 					&& properties[i].Type.IsModified(previousState[i], currentState[i], includeColumns[i], session);
 

Added: trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2510/Fixture.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2510/Fixture.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2510/Fixture.cs	2011-05-09 14:14:11 UTC (rev 5801)
@@ -0,0 +1,77 @@
+using System;
+using NHibernate.Cache;
+using NHibernate.Cfg;
+using NHibernate.Cfg.MappingSchema;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+
+namespace NHibernate.Test.NHSpecificTest.NH2510
+{
+	public class Image
+	{
+		public virtual int Id { get; set; }
+		public virtual byte[] Data { get; set; }
+	}
+	public class Fixture: TestCaseMappingByCode
+	{
+		protected override HbmMapping GetMappings()
+		{
+			var mapper = new ModelMapper();
+			mapper.Class<Image>(rc =>
+			                    {
+														rc.Cache(map => map.Usage(CacheUsage.NonstrictReadWrite));
+														rc.Id(x=> x.Id);
+														rc.Property(x => x.Data, map=> map.Lazy(true));
+			                    });
+			var mappings = mapper.CompileMappingForAllExplicitAddedEntities();
+			return mappings;
+		}
+
+		protected override void Configure(Cfg.Configuration configuration)
+		{
+			configuration.Cache(x=> x.Provider<HashtableCacheProvider>());
+		}
+
+		private class Scenario: IDisposable
+		{
+			private readonly ISessionFactory factory;
+
+			public Scenario(ISessionFactory factory)
+			{
+				this.factory = factory;
+				using (var session = factory.OpenSession())
+				using (session.BeginTransaction())
+				{
+					session.Persist(new Image { Id = 1 });
+					session.Transaction.Commit();
+				}
+			}
+
+			public void Dispose()
+			{
+				using (var session = factory.OpenSession())
+				using (session.BeginTransaction())
+				{
+					session.CreateQuery("delete from Image").ExecuteUpdate();
+					session.Transaction.Commit();
+				}				
+			}
+		}
+
+		[Test]
+		public void WhenReadFromCacheThenDoesNotThrow()
+		{
+			using (new Scenario(Sfi))
+			{
+				using (ISession s = OpenSession())
+				{
+					var book = s.Get<Image>(1);
+				}
+				using (ISession s = OpenSession())
+				{
+					var book = s.Get<Image>(1);
+				}
+			}
+		}
+	}
+}
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-05-08 22:59:17 UTC (rev 5800)
+++ trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-05-09 14:14:11 UTC (rev 5801)
@@ -784,6 +784,7 @@
     <Compile Include="NHSpecificTest\NH2505\Fixture.cs" />
     <Compile Include="NHSpecificTest\NH2507\Animal.cs" />
     <Compile Include="NHSpecificTest\NH2507\Fixture.cs" />
+    <Compile Include="NHSpecificTest\NH2510\Fixture.cs" />
     <Compile Include="NHSpecificTest\NH2527\FixtureWithNoBatcher.cs" />
     <Compile Include="NHSpecificTest\NH2527\Model.cs" />
     <Compile Include="NHSpecificTest\NH2530\Domain.cs" />


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5800] trunk/nhibernate/src/NHibernate

[<fab...@us...>]

Revision: 5800
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5800&view=rev
Author:   fabiomaulo
Date:     2011-05-08 22:59:17 +0000 (Sun, 08 May 2011)

Log Message:
-----------
Fixed class registration ambiguity resolution

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/ExplicitlyDeclaredModel.cs
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/SimpleModelInspector.cs
    trunk/nhibernate/src/NHibernate/NHibernate.csproj
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/ComponentMappingRegistrationTests.cs
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/JoinedSubclassMappingStrategyTests.cs
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/RootClassMappingStrategyTests.cs
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/SubclassMappingStrategyTests.cs
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/UnionSubclassMappingStrategyTests.cs
    trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj

Added Paths:
-----------
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/AbstractExplicitlyDeclaredModel.cs
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/MixAutomapping/CallCustomConditions.cs

Added: trunk/nhibernate/src/NHibernate/Mapping/ByCode/AbstractExplicitlyDeclaredModel.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/AbstractExplicitlyDeclaredModel.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/AbstractExplicitlyDeclaredModel.cs	2011-05-08 22:59:17 UTC (rev 5800)
@@ -0,0 +1,571 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+
+namespace NHibernate.Mapping.ByCode
+{
+	public abstract class AbstractExplicitlyDeclaredModel : IModelExplicitDeclarationsHolder
+	{
+		private readonly HashSet<MemberInfo> any = new HashSet<MemberInfo>();
+		private readonly HashSet<MemberInfo> arrays = new HashSet<MemberInfo>();
+		private readonly HashSet<MemberInfo> bags = new HashSet<MemberInfo>();
+		private readonly HashSet<System.Type> components = new HashSet<System.Type>();
+		private readonly HashSet<MemberInfo> dictionaries = new HashSet<MemberInfo>();
+		private readonly HashSet<MemberInfo> idBags = new HashSet<MemberInfo>();
+		private readonly HashSet<MemberInfo> lists = new HashSet<MemberInfo>();
+		private readonly HashSet<MemberInfo> manyToManyRelations = new HashSet<MemberInfo>();
+		private readonly HashSet<MemberInfo> manyToOneRelations = new HashSet<MemberInfo>();
+		private readonly HashSet<MemberInfo> naturalIds = new HashSet<MemberInfo>();
+		private readonly HashSet<MemberInfo> composedIds = new HashSet<MemberInfo>();
+		private readonly HashSet<MemberInfo> oneToManyRelations = new HashSet<MemberInfo>();
+		private readonly HashSet<MemberInfo> oneToOneRelations = new HashSet<MemberInfo>();
+		private readonly HashSet<MemberInfo> poids = new HashSet<MemberInfo>();
+		private readonly HashSet<MemberInfo> properties = new HashSet<MemberInfo>();
+		private readonly HashSet<MemberInfo> dynamicComponents = new HashSet<MemberInfo>();
+		private readonly Dictionary<MemberInfo, System.Type> dynamicComponentTemplates = new Dictionary<MemberInfo, System.Type>();
+		private readonly HashSet<MemberInfo> persistentMembers = new HashSet<MemberInfo>();
+		private readonly HashSet<System.Type> rootEntities = new HashSet<System.Type>();
+		private readonly HashSet<MemberInfo> sets = new HashSet<MemberInfo>();
+		private readonly HashSet<System.Type> tablePerClassEntities = new HashSet<System.Type>();
+		private readonly HashSet<System.Type> tablePerClassHierarchyEntities = new HashSet<System.Type>();
+		private readonly HashSet<System.Type> tablePerConcreteClassEntities = new HashSet<System.Type>();
+		private readonly HashSet<MemberInfo> versionProperties = new HashSet<MemberInfo>();
+		private readonly Dictionary<System.Type, HashSet<string>> typeSplitGroups = new Dictionary<System.Type, HashSet<string>>();
+		private readonly Dictionary<MemberInfo, string> memberSplitGroup = new Dictionary<MemberInfo, string>();
+		private readonly HashSet<SplitDefinition> splitDefinitions = new HashSet<SplitDefinition>();
+
+		#region Delayed registrations
+		// To allow a free organization of mappings, especially in presence of a IModelMapper not based exclusivelly on pure declarative mapping, and then
+		// provide a descriptive exception when there are some ambiguity, we have to delay the registration as late as we can
+		// (in practice to the moment we have to give a certain asnwer about the strategy used to represent a System.Type hierarchy).
+		private readonly Queue<System.Action> delayedRootEntityRegistrations = new Queue<System.Action>();
+		private readonly Dictionary<System.Type, List<Action<System.Type>>> delayedEntityRegistrations = new Dictionary<System.Type, List<Action<System.Type>>>();
+
+		#endregion
+
+		public IEnumerable<System.Type> RootEntities
+		{
+			get { return rootEntities; }
+		}
+
+		public IEnumerable<System.Type> Components
+		{
+			get { return components; }
+		}
+
+		public IEnumerable<System.Type> TablePerClassEntities
+		{
+			get { return tablePerClassEntities; }
+		}
+
+		public IEnumerable<System.Type> TablePerClassHierarchyEntities
+		{
+			get { return tablePerClassHierarchyEntities; }
+		}
+
+		public IEnumerable<System.Type> TablePerConcreteClassEntities
+		{
+			get { return tablePerConcreteClassEntities; }
+		}
+
+		public IEnumerable<MemberInfo> OneToOneRelations
+		{
+			get { return oneToOneRelations; }
+		}
+
+		public IEnumerable<MemberInfo> ManyToOneRelations
+		{
+			get { return manyToOneRelations; }
+		}
+
+		public IEnumerable<MemberInfo> ManyToManyRelations
+		{
+			get { return manyToManyRelations; }
+		}
+
+		public IEnumerable<MemberInfo> OneToManyRelations
+		{
+			get { return oneToManyRelations; }
+		}
+
+		public IEnumerable<MemberInfo> Any
+		{
+			get { return any; }
+		}
+
+		public IEnumerable<MemberInfo> Poids
+		{
+			get { return poids; }
+		}
+
+		public IEnumerable<MemberInfo> ComposedIds
+		{
+			get { return composedIds; }
+		}
+
+		public IEnumerable<MemberInfo> VersionProperties
+		{
+			get { return versionProperties; }
+		}
+
+		public IEnumerable<MemberInfo> NaturalIds
+		{
+			get { return naturalIds; }
+		}
+
+		public IEnumerable<MemberInfo> Sets
+		{
+			get { return sets; }
+		}
+
+		public IEnumerable<MemberInfo> Bags
+		{
+			get { return bags; }
+		}
+
+		public IEnumerable<MemberInfo> IdBags
+		{
+			get { return idBags; }
+		}
+
+		public IEnumerable<MemberInfo> Lists
+		{
+			get { return lists; }
+		}
+
+		public IEnumerable<MemberInfo> Arrays
+		{
+			get { return arrays; }
+		}
+
+		public IEnumerable<MemberInfo> Dictionaries
+		{
+			get { return dictionaries; }
+		}
+
+		public IEnumerable<MemberInfo> Properties
+		{
+			get { return properties; }
+		}
+
+		public IEnumerable<MemberInfo> DynamicComponents
+		{
+			get { return dynamicComponents; }
+		}
+
+		public IEnumerable<MemberInfo> PersistentMembers
+		{
+			get { return persistentMembers; }
+		}
+
+		public IEnumerable<SplitDefinition> SplitDefinitions
+		{
+			get { return splitDefinitions; }
+		}
+
+		public IEnumerable<string> GetSplitGroupsFor(System.Type type)
+		{
+			HashSet<string> splitsGroupsIds;
+			if (typeSplitGroups.TryGetValue(type, out splitsGroupsIds))
+			{
+				return splitsGroupsIds;
+			}
+			return Enumerable.Empty<string>();
+		}
+
+		public string GetSplitGroupFor(MemberInfo member)
+		{
+			var memberKey = member.GetMemberFromDeclaringType();
+			string splitGroup;
+			if (memberSplitGroup.TryGetValue(memberKey, out splitGroup))
+			{
+				return splitGroup;
+			}
+			return null;
+		}
+
+		public void AddAsRootEntity(System.Type type)
+		{
+			rootEntities.Add(type);
+			if (IsComponent(type))
+			{
+				throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered as entity and as component", type.FullName));
+			}
+		}
+
+		public abstract bool IsComponent(System.Type type);
+
+		public void AddAsComponent(System.Type type)
+		{
+			components.Add(type);
+			var rootEntity = GetSingleRootEntityOrNull(type);
+			if (rootEntity != null)
+			{
+				throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered as entity and as component", type.FullName));
+			}
+		}
+
+		public void AddAsTablePerClassEntity(System.Type type)
+		{
+			AddAsTablePerClassEntity(type, false);
+		}
+
+		protected virtual void AddAsTablePerClassEntity(System.Type type, bool rootEntityMustExists)
+		{
+			if(!rootEntityMustExists)
+			{
+				delayedRootEntityRegistrations.Enqueue(() => System.Array.ForEach(GetRootEntitentitiesOf(type).ToArray(), root=> tablePerClassEntities.Add(root)));
+				EnlistTypeRegistration(type, t => AddAsTablePerClassEntity(t, true));
+				return;
+			}
+			if (IsComponent(type))
+			{
+				throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered as entity and as component", type.FullName));
+			}
+			var rootEntity = GetSingleRootEntityOrNull(type);
+			if (rootEntity != null)
+			{
+				if (rootEntity.Equals(type))
+				{
+					throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered as root-entity and as subclass for table-per-class strategy", type.FullName));
+				}
+				if (IsMappedFor(tablePerClassHierarchyEntities, type) || IsMappedFor(tablePerConcreteClassEntities, type))
+				{
+					throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered with more than one class-hierarchy strategy", type.FullName));
+				}
+			}
+			else
+			{
+				throw new MappingException(string.Format("The root entity for {0} was never registered", type.FullName));
+			}
+		}
+
+		public void AddAsTablePerClassHierarchyEntity(System.Type type)
+		{
+			AddAsTablePerClassHierarchyEntity(type, false);
+		}
+
+		protected virtual void AddAsTablePerClassHierarchyEntity(System.Type type, bool rootEntityMustExists)
+		{
+			if (!rootEntityMustExists)
+			{
+				delayedRootEntityRegistrations.Enqueue(() => System.Array.ForEach(GetRootEntitentitiesOf(type).ToArray(), root => tablePerClassHierarchyEntities.Add(root)));
+				EnlistTypeRegistration(type, t => AddAsTablePerClassHierarchyEntity(t, true));
+				return;
+			}
+
+			if (IsComponent(type))
+			{
+				throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered as entity and as component", type.FullName));
+			}
+			var rootEntity = GetSingleRootEntityOrNull(type);
+			if (rootEntity != null)
+			{
+				if (rootEntity.Equals(type))
+				{
+					throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered as root-entity and as subclass for table-per-class-hierarchy strategy", type.FullName));
+				}
+				if (IsMappedFor(tablePerClassEntities, type) || IsMappedFor(tablePerConcreteClassEntities, type))
+				{
+					throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered with more than one class-hierarchy strategy", type.FullName));
+				}
+			}
+			else
+			{
+				throw new MappingException(string.Format("The root entity for {0} was never registered", type.FullName));
+			}
+		}
+
+		public void AddAsTablePerConcreteClassEntity(System.Type type)
+		{
+			AddAsTablePerConcreteClassEntity(type, false);
+		}
+
+		protected virtual void AddAsTablePerConcreteClassEntity(System.Type type, bool rootEntityMustExists)
+		{
+			if (!rootEntityMustExists)
+			{
+				delayedRootEntityRegistrations.Enqueue(() => System.Array.ForEach(GetRootEntitentitiesOf(type).ToArray(), root => tablePerConcreteClassEntities.Add(root)));
+				EnlistTypeRegistration(type, t => AddAsTablePerConcreteClassEntity(t, true));
+				return;
+			}
+
+			if (IsComponent(type))
+			{
+				throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered as entity and as component", type.FullName));
+			}
+			var rootEntity = GetSingleRootEntityOrNull(type);
+			if (rootEntity != null)
+			{
+				if (rootEntity.Equals(type))
+				{
+					throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered as root-entity and as subclass for table-per-concrete-class strategy", type.FullName));
+				}
+				if (IsMappedFor(tablePerClassEntities, type) || IsMappedFor(tablePerClassHierarchyEntities, type))
+				{
+					throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered with more than one class-hierarchy strategy", type.FullName));
+				}
+			}
+			else
+			{
+				throw new MappingException(string.Format("The root entity for {0} was never registered", type.FullName));
+			}
+		}
+
+		public void AddAsOneToOneRelation(MemberInfo member)
+		{
+			persistentMembers.Add(member);
+			oneToOneRelations.Add(member);
+		}
+
+		public void AddAsManyToOneRelation(MemberInfo member)
+		{
+			persistentMembers.Add(member);
+			manyToOneRelations.Add(member);
+		}
+
+		public void AddAsManyToManyRelation(MemberInfo member)
+		{
+			persistentMembers.Add(member);
+			manyToManyRelations.Add(member);
+		}
+
+		public void AddAsOneToManyRelation(MemberInfo member)
+		{
+			persistentMembers.Add(member);
+			oneToManyRelations.Add(member);
+		}
+
+		public void AddAsAny(MemberInfo member)
+		{
+			persistentMembers.Add(member);
+			any.Add(member);
+		}
+
+		public void AddAsPoid(MemberInfo member)
+		{
+			persistentMembers.Add(member);
+			poids.Add(member);
+		}
+
+		public void AddAsPartOfComposedId(MemberInfo member)
+		{
+			persistentMembers.Add(member);
+			composedIds.Add(member);
+		}
+
+		public void AddAsVersionProperty(MemberInfo member)
+		{
+			persistentMembers.Add(member);
+			versionProperties.Add(member);
+		}
+
+		public void AddAsNaturalId(MemberInfo member)
+		{
+			persistentMembers.Add(member);
+			naturalIds.Add(member);
+		}
+
+		public void AddAsSet(MemberInfo member)
+		{
+			persistentMembers.Add(member);
+			sets.Add(member);
+		}
+
+		public void AddAsBag(MemberInfo member)
+		{
+			persistentMembers.Add(member);
+			bags.Add(member);
+		}
+
+		public void AddAsIdBag(MemberInfo member)
+		{
+			persistentMembers.Add(member);
+			idBags.Add(member);
+		}
+
+		public void AddAsList(MemberInfo member)
+		{
+			persistentMembers.Add(member);
+			lists.Add(member);
+		}
+
+		public void AddAsArray(MemberInfo member)
+		{
+			persistentMembers.Add(member);
+			arrays.Add(member);
+		}
+
+		public void AddAsMap(MemberInfo member)
+		{
+			persistentMembers.Add(member);
+			dictionaries.Add(member);
+		}
+
+		public void AddAsProperty(MemberInfo member)
+		{
+			persistentMembers.Add(member);
+			properties.Add(member);
+		}
+
+		public void AddAsPersistentMember(MemberInfo member)
+		{
+			persistentMembers.Add(member);
+		}
+
+		public void AddAsPropertySplit(SplitDefinition definition)
+		{
+			if (definition == null)
+			{
+				return;
+			}
+			/* Note: if the user "jump/exclude" a class and then map the property in two subclasses the usage of GetMemberFromDeclaringType() may cause a problem
+			   for a legal usage... we will see when the case happen */
+			System.Type propertyContainer = definition.On;
+			string splitGroupId = definition.GroupId;
+			MemberInfo member = definition.Member;
+			var memberKey = member.GetMemberFromDeclaringType();
+			string splitGroup;
+			if (!memberSplitGroup.TryGetValue(memberKey, out splitGroup))
+			{
+				AddTypeSplits(propertyContainer, splitGroupId);
+				memberSplitGroup[memberKey] = splitGroupId;
+			}
+
+			splitDefinitions.Add(definition);
+		}
+
+		public void AddAsDynamicComponent(MemberInfo member, System.Type componentTemplate)
+		{
+			persistentMembers.Add(member);
+			dynamicComponents.Add(member);
+			dynamicComponentTemplates[member] = componentTemplate;
+		}
+
+		private void AddTypeSplits(System.Type propertyContainer, string splitGroupId)
+		{
+			HashSet<string> splitsGroupsIds;
+			typeSplitGroups.TryGetValue(propertyContainer, out splitsGroupsIds);
+			if(splitsGroupsIds == null)
+			{
+				splitsGroupsIds = new HashSet<string>();
+				typeSplitGroups[propertyContainer] = splitsGroupsIds;
+			}
+			splitsGroupsIds.Add(splitGroupId);
+		}
+
+		public virtual System.Type GetDynamicComponentTemplate(MemberInfo member)
+		{
+			System.Type template;
+			dynamicComponentTemplates.TryGetValue(member, out template);
+			return template ?? typeof(object);
+		}
+
+		protected System.Type GetSingleRootEntityOrNull(System.Type entityType)
+		{
+			var rootTypes = GetRootEntitentitiesOf(entityType).ToList();
+			if(rootTypes.Count > 1)
+			{
+				var sb = new StringBuilder(1024);
+				sb.AppendLine(string.Format("Ambiguous mapping for {0}. More than one root entities was found:", entityType.FullName));
+				foreach (var rootType in rootTypes.AsEnumerable().Reverse())
+				{
+					sb.AppendLine(rootType.FullName);
+				}
+				sb.AppendLine("Possible solutions:");
+				sb.AppendLine("- Merge the mappings of root entity in the one is representing the real root of the hierarchy.");
+				sb.AppendLine("- Inject a IModelInspector with a logic to discover the real root-entity.");
+				throw new MappingException(sb.ToString());
+			}
+			return rootTypes.SingleOrDefault(IsRootEntity);
+		}
+
+		protected IEnumerable<System.Type> GetRootEntitentitiesOf(System.Type entityType)
+		{
+			if (entityType == null)
+			{
+				yield break;
+			}
+			if(IsRootEntity(entityType))
+			{
+				yield return entityType;
+			}
+			foreach (var type in entityType.GetBaseTypes().Where(IsRootEntity))
+			{
+				yield return type;
+			}
+		}
+
+		public abstract bool IsRootEntity(System.Type entityType);
+
+		protected bool IsMappedForTablePerClassEntities(System.Type type)
+		{
+			return IsMappedFor(tablePerClassEntities, type);
+		}
+
+		protected bool IsMappedForTablePerClassHierarchyEntities(System.Type type)
+		{
+			return IsMappedFor(tablePerClassHierarchyEntities, type);
+		}
+
+		protected bool IsMappedForTablePerConcreteClassEntities(System.Type type)
+		{
+			return IsMappedFor(tablePerConcreteClassEntities, type);
+		}
+
+		private bool IsMappedFor(ICollection<System.Type> explicitMappedEntities, System.Type type)
+		{
+			bool isExplicitMapped = explicitMappedEntities.Contains(type);
+			bool isDerived = false;
+
+			if (!isExplicitMapped)
+			{
+				isDerived = type.GetBaseTypes().Any(explicitMappedEntities.Contains);
+				if (isDerived)
+				{
+					explicitMappedEntities.Add(type);
+				}
+			}
+			return isExplicitMapped || isDerived;
+		}
+
+		protected void EnlistTypeRegistration(System.Type type, Action<System.Type> registration)
+		{
+			List<Action<System.Type>> actions;
+			if (!delayedEntityRegistrations.TryGetValue(type, out actions))
+			{
+				actions = new List<Action<System.Type>>();
+				delayedEntityRegistrations[type] = actions;
+			}
+			actions.Add(registration);
+		}
+
+		protected void ExecuteDelayedTypeRegistration(System.Type type)
+		{
+			ExecuteDelayedRootEntitiesRegistrations();
+			List<Action<System.Type>> actions;
+			if (delayedEntityRegistrations.TryGetValue(type, out actions))
+			{
+				foreach (var action in actions)
+				{
+					action(type);
+				}
+			}
+		}
+
+		protected void ExecuteDelayedRootEntitiesRegistrations()
+		{
+			while (delayedRootEntityRegistrations.Count > 0)
+			{
+				delayedRootEntityRegistrations.Dequeue().Invoke();
+			}
+		}
+
+		protected bool HasDelayedEntityRegistration(System.Type type)
+		{
+			return delayedEntityRegistrations.ContainsKey(type);
+		}
+	}
+}
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/ExplicitlyDeclaredModel.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/ExplicitlyDeclaredModel.cs	2011-05-06 14:14:41 UTC (rev 5799)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/ExplicitlyDeclaredModel.cs	2011-05-08 22:59:17 UTC (rev 5800)
@@ -1,470 +1,32 @@
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 
 namespace NHibernate.Mapping.ByCode
 {
-	public class ExplicitlyDeclaredModel : IModelInspector, IModelExplicitDeclarationsHolder
+	public class ExplicitlyDeclaredModel : AbstractExplicitlyDeclaredModel, IModelInspector
 	{
-		private readonly HashSet<MemberInfo> any = new HashSet<MemberInfo>();
-		private readonly HashSet<MemberInfo> arrays = new HashSet<MemberInfo>();
-		private readonly HashSet<MemberInfo> bags = new HashSet<MemberInfo>();
-		private readonly HashSet<System.Type> components = new HashSet<System.Type>();
-		private readonly HashSet<MemberInfo> dictionaries = new HashSet<MemberInfo>();
-		private readonly HashSet<MemberInfo> idBags = new HashSet<MemberInfo>();
-		private readonly HashSet<MemberInfo> lists = new HashSet<MemberInfo>();
-		private readonly HashSet<MemberInfo> manyToManyRelations = new HashSet<MemberInfo>();
-		private readonly HashSet<MemberInfo> manyToOneRelations = new HashSet<MemberInfo>();
-		private readonly HashSet<MemberInfo> naturalIds = new HashSet<MemberInfo>();
-		private readonly HashSet<MemberInfo> composedIds = new HashSet<MemberInfo>();
-		private readonly HashSet<MemberInfo> oneToManyRelations = new HashSet<MemberInfo>();
-		private readonly HashSet<MemberInfo> oneToOneRelations = new HashSet<MemberInfo>();
-		private readonly HashSet<MemberInfo> poids = new HashSet<MemberInfo>();
-		private readonly HashSet<MemberInfo> properties = new HashSet<MemberInfo>();
-		private readonly HashSet<MemberInfo> dynamicComponents = new HashSet<MemberInfo>();
-		private readonly Dictionary<MemberInfo, System.Type> dynamicComponentTemplates = new Dictionary<MemberInfo, System.Type>();
-		private readonly HashSet<MemberInfo> persistentMembers = new HashSet<MemberInfo>();
-		private readonly HashSet<System.Type> rootEntities = new HashSet<System.Type>();
-		private readonly HashSet<MemberInfo> sets = new HashSet<MemberInfo>();
-		private readonly HashSet<System.Type> tablePerClassEntities = new HashSet<System.Type>();
-		private readonly HashSet<System.Type> tablePerClassHierarchyEntities = new HashSet<System.Type>();
-		private readonly HashSet<System.Type> tablePerConcreteClassEntities = new HashSet<System.Type>();
-		private readonly HashSet<MemberInfo> versionProperties = new HashSet<MemberInfo>();
-		private readonly Dictionary<System.Type, Action<System.Type>> delayedEntityRegistrations = new Dictionary<System.Type, Action<System.Type>>();
-		private readonly Dictionary<System.Type, HashSet<string>> typeSplitGroups = new Dictionary<System.Type, HashSet<string>>();
-		private readonly Dictionary<MemberInfo, string> memberSplitGroup = new Dictionary<MemberInfo, string>();
-		private readonly HashSet<SplitDefinition> splitDefinitions = new HashSet<SplitDefinition>();
-
-		#region IModelExplicitDeclarationsHolder Members
-
-		public IEnumerable<System.Type> RootEntities
-		{
-			get { return rootEntities; }
-		}
-
-		public IEnumerable<System.Type> Components
-		{
-			get { return components; }
-		}
-
-		public IEnumerable<System.Type> TablePerClassEntities
-		{
-			get { return tablePerClassEntities; }
-		}
-
-		public IEnumerable<System.Type> TablePerClassHierarchyEntities
-		{
-			get { return tablePerClassHierarchyEntities; }
-		}
-
-		public IEnumerable<System.Type> TablePerConcreteClassEntities
-		{
-			get { return tablePerConcreteClassEntities; }
-		}
-
-		public IEnumerable<MemberInfo> OneToOneRelations
-		{
-			get { return oneToOneRelations; }
-		}
-
-		public IEnumerable<MemberInfo> ManyToOneRelations
-		{
-			get { return manyToOneRelations; }
-		}
-
-		public IEnumerable<MemberInfo> ManyToManyRelations
-		{
-			get { return manyToManyRelations; }
-		}
-
-		public IEnumerable<MemberInfo> OneToManyRelations
-		{
-			get { return oneToManyRelations; }
-		}
-
-		public IEnumerable<MemberInfo> Any
-		{
-			get { return any; }
-		}
-
-		public IEnumerable<MemberInfo> Poids
-		{
-			get { return poids; }
-		}
-
-		public IEnumerable<MemberInfo> ComposedIds
-		{
-			get { return composedIds; }
-		}
-
-		public IEnumerable<MemberInfo> VersionProperties
-		{
-			get { return versionProperties; }
-		}
-
-		public IEnumerable<MemberInfo> NaturalIds
-		{
-			get { return naturalIds; }
-		}
-
-		public IEnumerable<MemberInfo> Sets
-		{
-			get { return sets; }
-		}
-
-		public IEnumerable<MemberInfo> Bags
-		{
-			get { return bags; }
-		}
-
-		public IEnumerable<MemberInfo> IdBags
-		{
-			get { return idBags; }
-		}
-
-		public IEnumerable<MemberInfo> Lists
-		{
-			get { return lists; }
-		}
-
-		public IEnumerable<MemberInfo> Arrays
-		{
-			get { return arrays; }
-		}
-
-		public IEnumerable<MemberInfo> Dictionaries
-		{
-			get { return dictionaries; }
-		}
-
-		public IEnumerable<MemberInfo> Properties
-		{
-			get { return properties; }
-		}
-
-		public IEnumerable<MemberInfo> DynamicComponents
-		{
-			get { return dynamicComponents; }
-		}
-
-		public IEnumerable<MemberInfo> PersistentMembers
-		{
-			get { return persistentMembers; }
-		}
-
-		public IEnumerable<SplitDefinition> SplitDefinitions
-		{
-			get { return splitDefinitions; }
-		}
-
-		public IEnumerable<string> GetSplitGroupsFor(System.Type type)
-		{
-			HashSet<string> splitsGroupsIds;
-			if (typeSplitGroups.TryGetValue(type, out splitsGroupsIds))
-			{
-				return splitsGroupsIds;
-			}
-			return Enumerable.Empty<string>();
-		}
-
-		public string GetSplitGroupFor(MemberInfo member)
-		{
-			var memberKey = member.GetMemberFromDeclaringType();
-			string splitGroup;
-			if (memberSplitGroup.TryGetValue(memberKey, out splitGroup))
-			{
-				return splitGroup;
-			}
-			return null;
-		}
-
-		public void AddAsRootEntity(System.Type type)
-		{
-			if (IsComponent(type))
-			{
-				throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered as entity and as component", type.FullName));
-			}
-			rootEntities.Add(type);
-		}
-
-		public void AddAsComponent(System.Type type)
-		{
-			var rootEntity = GetRootEntityOrNull(type);
-			if (rootEntity != null)
-			{
-				throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered as entity and as component", type.FullName));
-			}
-			components.Add(type);
-		}
-
-		public void AddAsTablePerClassEntity(System.Type type)
-		{
-			AddAsTablePerClassEntity(type, false);
-		}
-
-		public void AddAsTablePerClassEntity(System.Type type, bool rootEntityMustExists)
-		{
-			if (IsComponent(type))
-			{
-				throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered as entity and as component", type.FullName));
-			}
-			var rootEntity = GetRootEntityOrNull(type);
-			if (rootEntity != null)
-			{
-				if (rootEntity.Equals(type))
-				{
-					throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered as root-entity and as subclass for table-per-class strategy", type.FullName));
-				}
-				if (IsMappedFor(tablePerClassHierarchyEntities, type) || IsMappedFor(tablePerConcreteClassEntities, type))
-				{
-					throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered with more than one class-hierarchy strategy", type.FullName));
-				}
-				tablePerClassEntities.Add(rootEntity);
-			}
-			else
-			{
-				if(rootEntityMustExists)
-				{
-					throw new MappingException(string.Format("The root entity for {0} was never registered", type.FullName));
-				}
-				EnlistTypeRegistration(type, t => AddAsTablePerClassEntity(t, true));
-			}
-		}
-
-		public void AddAsTablePerClassHierarchyEntity(System.Type type)
-		{
-			AddAsTablePerClassHierarchyEntity(type, false);
-		}
-
-		public void AddAsTablePerClassHierarchyEntity(System.Type type, bool rootEntityMustExists)
-		{
-			if (IsComponent(type))
-			{
-				throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered as entity and as component", type.FullName));
-			}
-			var rootEntity = GetRootEntityOrNull(type);
-			if (rootEntity != null)
-			{
-				if (rootEntity.Equals(type))
-				{
-					throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered as root-entity and as subclass for table-per-class-hierarchy strategy", type.FullName));
-				}
-				if (IsMappedFor(tablePerClassEntities, type) || IsMappedFor(tablePerConcreteClassEntities, type))
-				{
-					throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered with more than one class-hierarchy strategy", type.FullName));
-				}
-				tablePerClassHierarchyEntities.Add(rootEntity);
-			}
-			else
-			{
-				if (rootEntityMustExists)
-				{
-					throw new MappingException(string.Format("The root entity for {0} was never registered", type.FullName));
-				}
-				EnlistTypeRegistration(type, t => AddAsTablePerClassHierarchyEntity(t, true));
-			}
-		}
-
-		public void AddAsTablePerConcreteClassEntity(System.Type type)
-		{
-			AddAsTablePerConcreteClassEntity(type, false);
-		}
-
-		public void AddAsTablePerConcreteClassEntity(System.Type type, bool rootEntityMustExists)
-		{
-			if (IsComponent(type))
-			{
-				throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered as entity and as component", type.FullName));
-			}
-			var rootEntity = GetRootEntityOrNull(type);
-			if (rootEntity != null)
-			{
-				if (rootEntity.Equals(type))
-				{
-					throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered as root-entity and as subclass for table-per-concrete-class strategy", type.FullName));
-				}
-				if (IsMappedFor(tablePerClassEntities, type) || IsMappedFor(tablePerClassHierarchyEntities, type))
-				{
-					throw new MappingException(string.Format("Ambiguous mapping of {0}. It was registered with more than one class-hierarchy strategy", type.FullName));
-				}
-				tablePerConcreteClassEntities.Add(rootEntity);
-			}
-			else
-			{
-				if (rootEntityMustExists)
-				{
-					throw new MappingException(string.Format("The root entity for {0} was never registered", type.FullName));
-				}
-				EnlistTypeRegistration(type, t => AddAsTablePerConcreteClassEntity(t, true));
-			}
-		}
-
-		public void AddAsOneToOneRelation(MemberInfo member)
-		{
-			persistentMembers.Add(member);
-			oneToOneRelations.Add(member);
-		}
-
-		public void AddAsManyToOneRelation(MemberInfo member)
-		{
-			persistentMembers.Add(member);
-			manyToOneRelations.Add(member);
-		}
-
-		public void AddAsManyToManyRelation(MemberInfo member)
-		{
-			persistentMembers.Add(member);
-			manyToManyRelations.Add(member);
-		}
-
-		public void AddAsOneToManyRelation(MemberInfo member)
-		{
-			persistentMembers.Add(member);
-			oneToManyRelations.Add(member);
-		}
-
-		public void AddAsAny(MemberInfo member)
-		{
-			persistentMembers.Add(member);
-			any.Add(member);
-		}
-
-		public void AddAsPoid(MemberInfo member)
-		{
-			persistentMembers.Add(member);
-			poids.Add(member);
-		}
-
-		public void AddAsPartOfComposedId(MemberInfo member)
-		{
-			persistentMembers.Add(member);
-			composedIds.Add(member);
-		}
-
-		public void AddAsVersionProperty(MemberInfo member)
-		{
-			persistentMembers.Add(member);
-			versionProperties.Add(member);
-		}
-
-		public void AddAsNaturalId(MemberInfo member)
-		{
-			persistentMembers.Add(member);
-			naturalIds.Add(member);
-		}
-
-		public void AddAsSet(MemberInfo member)
-		{
-			persistentMembers.Add(member);
-			sets.Add(member);
-		}
-
-		public void AddAsBag(MemberInfo member)
-		{
-			persistentMembers.Add(member);
-			bags.Add(member);
-		}
-
-		public void AddAsIdBag(MemberInfo member)
-		{
-			persistentMembers.Add(member);
-			idBags.Add(member);
-		}
-
-		public void AddAsList(MemberInfo member)
-		{
-			persistentMembers.Add(member);
-			lists.Add(member);
-		}
-
-		public void AddAsArray(MemberInfo member)
-		{
-			persistentMembers.Add(member);
-			arrays.Add(member);
-		}
-
-		public void AddAsMap(MemberInfo member)
-		{
-			persistentMembers.Add(member);
-			dictionaries.Add(member);
-		}
-
-		public void AddAsProperty(MemberInfo member)
-		{
-			persistentMembers.Add(member);
-			properties.Add(member);
-		}
-
-		public void AddAsPersistentMember(MemberInfo member)
-		{
-			persistentMembers.Add(member);
-		}
-
-		public void AddAsPropertySplit(SplitDefinition definition)
-		{
-			if (definition == null)
-			{
-				return;
-			}
-			/* Note: if the user "jump/exclude" a class and then map the property in two subclasses the usage of GetMemberFromDeclaringType() may cause a problem
-			   for a legal usage... we will see when the case happen */
-			System.Type propertyContainer = definition.On;
-			string splitGroupId = definition.GroupId;
-			MemberInfo member = definition.Member;
-			var memberKey = member.GetMemberFromDeclaringType();
-			string splitGroup;
-			if (!memberSplitGroup.TryGetValue(memberKey, out splitGroup))
-			{
-				AddTypeSplits(propertyContainer, splitGroupId);
-				memberSplitGroup[memberKey] = splitGroupId;
-			}
-
-			splitDefinitions.Add(definition);
-		}
-
-		public void AddAsDynamicComponent(MemberInfo member, System.Type componentTemplate)
-		{
-			persistentMembers.Add(member);
-			dynamicComponents.Add(member);
-			dynamicComponentTemplates[member] = componentTemplate;
-		}
-
-		private void AddTypeSplits(System.Type propertyContainer, string splitGroupId)
-		{
-			HashSet<string> splitsGroupsIds;
-			typeSplitGroups.TryGetValue(propertyContainer, out splitsGroupsIds);
-			if(splitsGroupsIds == null)
-			{
-				splitsGroupsIds = new HashSet<string>();
-				typeSplitGroups[propertyContainer] = splitsGroupsIds;
-			}
-			splitsGroupsIds.Add(splitGroupId);
-		}
-
-		#endregion
-
 		#region Implementation of IModelInspector
 
-		public virtual bool IsRootEntity(System.Type type)
+		public override bool IsRootEntity(System.Type type)
 		{
-			return rootEntities.Contains(type);
+			return RootEntities.Contains(type);
 		}
 
-		public virtual bool IsComponent(System.Type type)
+		public override bool IsComponent(System.Type type)
 		{
-			return components.Contains(type);
+			return Components.Contains(type);
 		}
 
 		public virtual bool IsEntity(System.Type type)
 		{
-			return rootEntities.Contains(type) || type.GetBaseTypes().Any(t => rootEntities.Contains(t)) || HasDelayedEntityRegistration(type);
+			return RootEntities.Contains(type) || type.GetBaseTypes().Any(t => RootEntities.Contains(t)) || HasDelayedEntityRegistration(type);
 		}
 
 		public virtual bool IsTablePerClass(System.Type type)
 		{
 			ExecuteDelayedTypeRegistration(type);
-			return IsMappedFor(tablePerClassEntities, type);
+			return IsMappedForTablePerClassEntities(type);
 		}
 
 		public virtual bool IsTablePerClassSplit(System.Type type, object splitGroupId, MemberInfo member)
@@ -475,166 +37,110 @@
 		public virtual bool IsTablePerClassHierarchy(System.Type type)
 		{
 			ExecuteDelayedTypeRegistration(type);
-			return IsMappedFor(tablePerClassHierarchyEntities, type);
+			return IsMappedForTablePerClassHierarchyEntities(type);
 		}
 
 		public virtual bool IsTablePerConcreteClass(System.Type type)
 		{
 			ExecuteDelayedTypeRegistration(type);
-			return IsMappedFor(tablePerConcreteClassEntities, type);
+			return IsMappedForTablePerConcreteClassEntities(type);
 		}
 
 		public virtual bool IsOneToOne(MemberInfo member)
 		{
-			return oneToOneRelations.Contains(member);
+			return OneToOneRelations.Contains(member);
 		}
 
 		public virtual bool IsManyToOne(MemberInfo member)
 		{
-			return manyToOneRelations.Contains(member);
+			return ManyToOneRelations.Contains(member);
 		}
 
 		public virtual bool IsManyToMany(MemberInfo member)
 		{
-			return manyToManyRelations.Contains(member);
+			return ManyToManyRelations.Contains(member);
 		}
 
 		public virtual bool IsOneToMany(MemberInfo member)
 		{
-			return oneToManyRelations.Contains(member);
+			return OneToManyRelations.Contains(member);
 		}
 
 		public virtual bool IsAny(MemberInfo member)
 		{
-			return any.Contains(member);
+			return Any.Contains(member);
 		}
 
 		public virtual bool IsPersistentId(MemberInfo member)
 		{
-			return poids.Contains(member);
+			return Poids.Contains(member);
 		}
 
 		public bool IsMemberOfComposedId(MemberInfo member)
 		{
-			return composedIds.Contains(member);
+			return ComposedIds.Contains(member);
 		}
 
 		public virtual bool IsVersion(MemberInfo member)
 		{
-			return versionProperties.Contains(member);
+			return VersionProperties.Contains(member);
 		}
 
 		public virtual bool IsMemberOfNaturalId(MemberInfo member)
 		{
-			return naturalIds.Contains(member);
+			return NaturalIds.Contains(member);
 		}
 
 		public virtual bool IsPersistentProperty(MemberInfo member)
 		{
-			return persistentMembers.Contains(member);
+			return PersistentMembers.Contains(member);
 		}
 
 		public virtual bool IsSet(MemberInfo role)
 		{
-			return sets.Contains(role);
+			return Sets.Contains(role);
 		}
 
 		public virtual bool IsBag(MemberInfo role)
 		{
-			return bags.Contains(role);
+			return Bags.Contains(role);
 		}
 
 		public virtual bool IsIdBag(MemberInfo role)
 		{
-			return idBags.Contains(role);
+			return IdBags.Contains(role);
 		}
 
 		public virtual bool IsList(MemberInfo role)
 		{
-			return lists.Contains(role);
+			return Lists.Contains(role);
 		}
 
 		public virtual bool IsArray(MemberInfo role)
 		{
-			return arrays.Contains(role);
+			return Arrays.Contains(role);
 		}
 
 		public virtual bool IsDictionary(MemberInfo role)
 		{
-			return dictionaries.Contains(role);
+			return Dictionaries.Contains(role);
 		}
 
 		public virtual bool IsProperty(MemberInfo member)
 		{
-			return properties.Contains(member);
+			return Properties.Contains(member);
 		}
 
-		public bool IsDynamicComponent(MemberInfo member)
+		public virtual bool IsDynamicComponent(MemberInfo member)
 		{
-			return dynamicComponents.Contains(member);
+			return DynamicComponents.Contains(member);
 		}
 
-		public System.Type GetDynamicComponentTemplate(MemberInfo member)
+		public virtual IEnumerable<string> GetPropertiesSplits(System.Type type)
 		{
-			System.Type template;
-			dynamicComponentTemplates.TryGetValue(member, out template);
-			return template ?? typeof(object);
-		}
-
-		public IEnumerable<string> GetPropertiesSplits(System.Type type)
-		{
 			return GetSplitGroupsFor(type);
 		}
 
 		#endregion
-
-		protected System.Type GetRootEntityOrNull(System.Type entityType)
-		{
-			if (entityType == null)
-			{
-				return null;
-			}
-			if (IsRootEntity(entityType))
-			{
-				return entityType;
-			}
-			return entityType.GetBaseTypes().SingleOrDefault(IsRootEntity);
-		}
-
-		protected bool IsMappedFor(ICollection<System.Type> explicitMappedEntities, System.Type type)
-		{
-			bool isExplicitMapped = explicitMappedEntities.Contains(type);
-			bool isDerived = false;
-
-			if (!isExplicitMapped)
-			{
-				isDerived = type.GetBaseTypes().Any(explicitMappedEntities.Contains);
-				if (isDerived)
-				{
-					explicitMappedEntities.Add(type);
-				}
-			}
-			return isExplicitMapped || isDerived;
-		}
-
-		protected void EnlistTypeRegistration(System.Type type, Action<System.Type> registration)
-		{
-			delayedEntityRegistrations.Add(type, registration);
-		}
-
-		protected void ExecuteDelayedTypeRegistration(System.Type type)
-		{
-			Action<System.Type> registration;
-			if(delayedEntityRegistrations.TryGetValue(type, out registration))
-			{
-				delayedEntityRegistrations.Remove(type);
-				registration(type);
-			}
-		}
-
-		protected bool HasDelayedEntityRegistration(System.Type type)
-		{
-			return delayedEntityRegistrations.ContainsKey(type);
-		}
 	}
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/SimpleModelInspector.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/SimpleModelInspector.cs	2011-05-06 14:14:41 UTC (rev 5799)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/SimpleModelInspector.cs	2011-05-08 22:59:17 UTC (rev 5800)
@@ -11,8 +11,151 @@
 	/// </summary>
 	public class SimpleModelInspector : IModelInspector, IModelExplicitDeclarationsHolder
 	{
-		private readonly ExplicitlyDeclaredModel declaredModel = new ExplicitlyDeclaredModel();
+		private class MixinDeclaredModel : AbstractExplicitlyDeclaredModel
+		{
+			private readonly IModelInspector inspector;
 
+			public MixinDeclaredModel(IModelInspector inspector)
+			{
+				this.inspector = inspector;
+			}
+
+			public override bool IsComponent(System.Type type)
+			{
+				return Components.Contains(type);
+			}
+
+			public override bool IsRootEntity(System.Type entityType)
+			{
+				return inspector.IsRootEntity(entityType);
+			}
+
+			public bool IsEntity(System.Type type)
+			{
+				return RootEntities.Contains(type) || type.GetBaseTypes().Any(t => RootEntities.Contains(t)) || HasDelayedEntityRegistration(type);
+			}
+
+			public bool IsTablePerClass(System.Type type)
+			{
+				ExecuteDelayedTypeRegistration(type);
+				return IsMappedForTablePerClassEntities(type);
+			}
+
+			public bool IsTablePerClassSplit(System.Type type, object splitGroupId, MemberInfo member)
+			{
+				return Equals(splitGroupId, GetSplitGroupFor(member));
+			}
+
+			public bool IsTablePerClassHierarchy(System.Type type)
+			{
+				ExecuteDelayedTypeRegistration(type);
+				return IsMappedForTablePerClassHierarchyEntities(type);
+			}
+
+			public bool IsTablePerConcreteClass(System.Type type)
+			{
+				ExecuteDelayedTypeRegistration(type);
+				return IsMappedForTablePerConcreteClassEntities(type);
+			}
+
+			public bool IsOneToOne(MemberInfo member)
+			{
+				return OneToOneRelations.Contains(member);
+			}
+
+			public bool IsManyToOne(MemberInfo member)
+			{
+				return ManyToOneRelations.Contains(member);
+			}
+
+			public bool IsManyToMany(MemberInfo member)
+			{
+				return ManyToManyRelations.Contains(member);
+			}
+
+			public bool IsOneToMany(MemberInfo member)
+			{
+				return OneToManyRelations.Contains(member);
+			}
+
+			public bool IsAny(MemberInfo member)
+			{
+				return Any.Contains(member);
+			}
+
+			public bool IsPersistentId(MemberInfo member)
+			{
+				return Poids.Contains(member);
+			}
+
+			public bool IsMemberOfComposedId(MemberInfo member)
+			{
+				return ComposedIds.Contains(member);
+			}
+
+			public bool IsVersion(MemberInfo member)
+			{
+				return VersionProperties.Contains(member);
+			}
+
+			public bool IsMemberOfNaturalId(MemberInfo member)
+			{
+				return NaturalIds.Contains(member);
+			}
+
+			public bool IsPersistentProperty(MemberInfo member)
+			{
+				return PersistentMembers.Contains(member);
+			}
+
+			public bool IsSet(MemberInfo role)
+			{
+				return Sets.Contains(role);
+			}
+
+			public bool IsBag(MemberInfo role)
+			{
+				return Bags.Contains(role);
+			}
+
+			public bool IsIdBag(MemberInfo role)
+			{
+				return IdBags.Contains(role);
+			}
+
+			public bool IsList(MemberInfo role)
+			{
+				return Lists.Contains(role);
+			}
+
+			public bool IsArray(MemberInfo role)
+			{
+				return Arrays.Contains(role);
+			}
+
+			public bool IsDictionary(MemberInfo role)
+			{
+				return Dictionaries.Contains(role);
+			}
+
+			public bool IsProperty(MemberInfo member)
+			{
+				return Properties.Contains(member);
+			}
+
+			public bool IsDynamicComponent(MemberInfo member)
+			{
+				return DynamicComponents.Contains(member);
+			}
+
+			public IEnumerable<string> GetPropertiesSplits(System.Type type)
+			{
+				return GetSplitGroupsFor(type);
+			}
+		}
+
+		private readonly MixinDeclaredModel declaredModel;
+
 		private Func<System.Type, bool, bool> isEntity = (t, declared) => declared;
 		private Func<System.Type, bool, bool> isRootEntity;
 		private Func<System.Type, bool, bool> isTablePerClass;
@@ -56,11 +199,12 @@
 			isDictionary = (m, declared) => declared || MatchCollection(m, MatchDictionaryMember);
 			isManyToOne = (m, declared) => declared || MatchManyToOne(m);
 			isOneToMany = (m, declared) => declared || MatchOneToMany(m);
+			declaredModel = new MixinDeclaredModel(this);
 		}
 
 		private bool MatchRootEntity(System.Type type)
 		{
-			return type.IsClass && typeof(object).Equals(type.BaseType);
+			return type.IsClass && typeof(object).Equals(type.BaseType) && ((IModelInspector)this).IsEntity(type);
 		}
 
 		private bool MatchTablePerClass(System.Type type)
@@ -213,6 +357,10 @@
 			const BindingFlags flattenHierarchyMembers =
 				BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
 
+			if (declaredModel.IsEntity(subject))
+			{
+				return false;
+			}
 			var modelInspector = (IModelInspector) this;
 			return !subject.IsEnum && (subject.Namespace == null || !subject.Namespace.StartsWith("System")) /* hack */
 							&& !modelInspector.IsEntity(subject)
@@ -224,7 +372,10 @@
 		{
 			const BindingFlags flattenHierarchyMembers =
 				BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
-
+			if(declaredModel.Components.Contains(subject))
+			{
+				return false;
+			}
 			var modelInspector = (IModelInspector) this;
 			return subject.IsClass &&
 			       subject.GetProperties(flattenHierarchyMembers).Cast<MemberInfo>().Concat(subject.GetFields(flattenHierarchyMembers)).Any(m => modelInspector.IsPersistentId(m));
@@ -488,13 +639,13 @@
 
 		bool IModelInspector.IsRootEntity(System.Type type)
 		{
-			bool declaredResult = declaredModel.IsRootEntity(type);
+			bool declaredResult = declaredModel.RootEntities.Contains(type);
 			return isRootEntity(type, declaredResult);
 		}
 
 		bool IModelInspector.IsComponent(System.Type type)
 		{
-			bool declaredResult = declaredModel.IsComponent(type);
+			bool declaredResult = declaredModel.Components.Contains(type);
 			return isComponent(type, declaredResult);
 		}
 

Modified: trunk/nhibernate/src/NHibernate/NHibernate.csproj
===================================================================
--- trunk/nhibernate/src/NHibernate/NHibernate.csproj	2011-05-06 14:14:41 UTC (rev 5799)
+++ trunk/nhibernate/src/NHibernate/NHibernate.csproj	2011-05-08 22:59:17 UTC (rev 5800)
@@ -284,6 +284,7 @@
     <Compile Include="Mapping\Any.cs" />
     <Compile Include="Mapping\Array.cs" />
     <Compile Include="Mapping\Bag.cs" />
+    <Compile Include="Mapping\ByCode\AbstractExplicitlyDeclaredModel.cs" />
     <Compile Include="Mapping\ByCode\CacheInclude.cs" />
     <Compile Include="Mapping\ByCode\CacheUsage.cs" />
     <Compile Include="Mapping\ByCode\Cascade.cs" />

Modified: trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/ComponentMappingRegistrationTests.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/ComponentMappingRegistrationTests.cs	2011-05-06 14:14:41 UTC (rev 5799)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/ComponentMappingRegistrationTests.cs	2011-05-08 22:59:17 UTC (rev 5800)
@@ -42,27 +42,39 @@
 		public void WhenRegisteredAsComponetThenCantRegisterAsJoinedSubclass()
 		{
 			var inspector = new ExplicitlyDeclaredModel();
-			inspector.AddAsComponent(typeof(MyComponent));
+			inspector.AddAsComponent(typeof (MyComponent));
 
-			inspector.Executing(x => x.AddAsTablePerClassEntity(typeof(MyComponent))).Throws<MappingException>();
+			Executing.This(() =>
+			               {
+			               	inspector.AddAsTablePerClassEntity(typeof (MyComponent));
+			               	inspector.IsTablePerClass(typeof (MyComponent));
+			               }).Should().Throw<MappingException>();
 		}
 
 		[Test]
 		public void WhenRegisteredAsComponetThenCantRegisterAsSubclass()
 		{
 			var inspector = new ExplicitlyDeclaredModel();
-			inspector.AddAsComponent(typeof(MyComponent));
+			inspector.AddAsComponent(typeof (MyComponent));
 
-			inspector.Executing(x => x.AddAsTablePerClassHierarchyEntity(typeof(MyComponent))).Throws<MappingException>();
+			Executing.This(() =>
+			               {
+			               	inspector.AddAsTablePerClassHierarchyEntity(typeof (MyComponent));
+			               	inspector.IsTablePerClassHierarchy(typeof (MyComponent));
+			               }).Should().Throw<MappingException>();
 		}
 
 		[Test]
 		public void WhenRegisteredAsComponetThenCantRegisterAsUnionSubclass()
 		{
 			var inspector = new ExplicitlyDeclaredModel();
-			inspector.AddAsComponent(typeof(MyComponent));
+			inspector.AddAsComponent(typeof (MyComponent));
 
-			inspector.Executing(x => x.AddAsTablePerConcreteClassEntity(typeof(MyComponent))).Throws<MappingException>();
+			Executing.This(() =>
+			               {
+			               	inspector.AddAsTablePerConcreteClassEntity(typeof (MyComponent));
+			               	inspector.IsTablePerConcreteClass(typeof (MyComponent));
+			               }).Should().Throw<MappingException>();
 		}
 	}
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/JoinedSubclassMappingStrategyTests.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/JoinedSubclassMappingStrategyTests.cs	2011-05-06 14:14:41 UTC (rev 5799)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/JoinedSubclassMappingStrategyTests.cs	2011-05-08 22:59:17 UTC (rev 5800)
@@ -47,20 +47,28 @@
 		public void WhenRegisteredAsJoinedSubclassThenCantRegisterAsSubclass()
 		{
 			var inspector = new ExplicitlyDeclaredModel();
-			inspector.AddAsRootEntity(typeof(MyClass));
-			inspector.AddAsTablePerClassEntity(typeof(Inherited1));
+			inspector.AddAsRootEntity(typeof (MyClass));
+			inspector.AddAsTablePerClassEntity(typeof (Inherited1));
 
-			inspector.Executing(x => x.AddAsTablePerClassHierarchyEntity(typeof(Inherited1))).Throws<MappingException>();
+			Executing.This(() =>
+			               {
+			               	inspector.AddAsTablePerClassHierarchyEntity(typeof (Inherited1));
+			               	inspector.IsTablePerClass(typeof (Inherited1));
+			               }).Should().Throw<MappingException>();
 		}
 
 		[Test]
 		public void WhenRegisteredAsJoinedSubclassThenCantRegisterAsUnionSubclass()
 		{
 			var inspector = new ExplicitlyDeclaredModel();
-			inspector.AddAsRootEntity(typeof(MyClass));
-			inspector.AddAsTablePerClassEntity(typeof(Inherited1));
+			inspector.AddAsRootEntity(typeof (MyClass));
+			inspector.AddAsTablePerClassEntity(typeof (Inherited1));
 
-			inspector.Executing(x => x.AddAsTablePerConcreteClassEntity(typeof(Inherited1))).Throws<MappingException>();
+			Executing.This(() =>
+			               {
+			               	inspector.AddAsTablePerConcreteClassEntity(typeof (Inherited1));
+			               	inspector.IsTablePerClass(typeof (Inherited1));
+			               }).Should().Throw<MappingException>();
 		}
 
 		[Test]

Modified: trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/RootClassMappingStrategyTests.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/RootClassMappingStrategyTests.cs	2011-05-06 14:14:41 UTC (rev 5799)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/RootClassMappingStrategyTests.cs	2011-05-08 22:59:17 UTC (rev 5800)
@@ -103,24 +103,36 @@
 		public void WhenRegisteredAsRootThenCantRegisterAsSubclass()
 		{
 			var inspector = new ExplicitlyDeclaredModel();
-			inspector.AddAsRootEntity(typeof(MyClass));
-			inspector.Executing(x=> x.AddAsTablePerClassEntity(typeof(MyClass))).Throws<MappingException>();
+			inspector.AddAsRootEntity(typeof (MyClass));
+			Executing.This(() =>
+			               {
+			               	inspector.AddAsTablePerClassHierarchyEntity(typeof (MyClass));
+			               	inspector.IsTablePerClassHierarchy(typeof (MyClass));
+			               }).Should().Throw<MappingException>();
 		}
 
 		[Test]
 		public void WhenRegisteredAsRootThenCantRegisterAsJoinedSubclass()
 		{
 			var inspector = new ExplicitlyDeclaredModel();
-			inspector.AddAsRootEntity(typeof(MyClass));
-			inspector.Executing(x => x.AddAsTablePerClassEntity(typeof(MyClass))).Throws<MappingException>();
+			inspector.AddAsRootEntity(typeof (MyClass));
+			Executing.This(() =>
+			               {
+			               	inspector.AddAsTablePerClassEntity(typeof (MyClass));
+			               	inspector.IsTablePerClass(typeof (MyClass));
+			               }).Should().Throw<MappingException>();
 		}
 
 		[Test]
 		public void WhenRegisteredAsRootThenCantRegisterAsUnionSubclass()
 		{
 			var inspector = new ExplicitlyDeclaredModel();
-			inspector.AddAsRootEntity(typeof(MyClass));
-			inspector.Executing(x => x.AddAsTablePerClassEntity(typeof(MyClass))).Throws<MappingException>();
+			inspector.AddAsRootEntity(typeof (MyClass));
+			Executing.This(() =>
+			               {
+			               	inspector.AddAsTablePerConcreteClassEntity(typeof (MyClass));
+			               	inspector.IsTablePerClass(typeof (MyClass));
+			               }).Should().Throw<MappingException>();
 		}
 
 		[Test]
@@ -131,5 +143,18 @@
 
 			inspector.IsEntity(typeof(MyClass)).Should().Be.True();
 		}
+
+		[Test]
+		public void WhenMultipleRootRegisteredThenThrowsMappingException()
+		{
+			var inspector = new ExplicitlyDeclaredModel();
+			inspector.AddAsRootEntity(typeof(MyClass));
+			inspector.AddAsRootEntity(typeof(Inherited1));
+			Executing.This(()=>
+			               {
+			               	inspector.AddAsTablePerClassEntity(typeof(Inherited2));
+											inspector.IsTablePerClass(typeof(Inherited2));
+			               }).Should().Throw<MappingException>();
+		}
 	}
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/SubclassMappingStrategyTests.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/SubclassMappingStrategyTests.cs	2011-05-06 14:14:41 UTC (rev 5799)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/SubclassMappingStrategyTests.cs	2011-05-08 22:59:17 UTC (rev 5800)
@@ -50,17 +50,25 @@
 			inspector.AddAsRootEntity(typeof(MyClass));
 			inspector.AddAsTablePerClassHierarchyEntity(typeof(Inherited1));
 
-			inspector.Executing(x => x.AddAsTablePerClassEntity(typeof(Inherited1))).Throws<MappingException>();
+			Executing.This(() =>
+										 {
+											 inspector.AddAsTablePerClassEntity(typeof(Inherited1));
+											 inspector.IsTablePerClass(typeof(Inherited1));
+										 }).Should().Throw<MappingException>();
 		}
 
 		[Test]
 		public void WhenRegisteredAsSubclassThenCantRegisterAsUnionSubclass()
 		{
 			var inspector = new ExplicitlyDeclaredModel();
-			inspector.AddAsRootEntity(typeof(MyClass));
-			inspector.AddAsTablePerClassHierarchyEntity(typeof(Inherited1));
+			inspector.AddAsRootEntity(typeof (MyClass));
+			inspector.AddAsTablePerClassHierarchyEntity(typeof (Inherited1));
 
-			inspector.Executing(x => x.AddAsTablePerConcreteClassEntity(typeof(Inherited1))).Throws<MappingException>();
+			Executing.This(() =>
+			               {
+			               	inspector.AddAsTablePerConcreteClassEntity(typeof (Inherited1));
+			               	inspector.IsTablePerClassHierarchy(typeof (Inherited1));
+			               }).Should().Throw<MappingException>();
 		}
 
 		[Test]

Modified: trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/UnionSubclassMappingStrategyTests.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/UnionSubclassMappingStrategyTests.cs	2011-05-06 14:14:41 UTC (rev 5799)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/UnionSubclassMappingStrategyTests.cs	2011-05-08 22:59:17 UTC (rev 5800)
@@ -47,20 +47,28 @@
 		public void WhenRegisteredAsUnionSubclassThenCantRegisterAsSubclass()
 		{
 			var inspector = new ExplicitlyDeclaredModel();
-			inspector.AddAsRootEntity(typeof(MyClass));
-			inspector.AddAsTablePerConcreteClassEntity(typeof(Inherited1));
+			inspector.AddAsRootEntity(typeof (MyClass));
+			inspector.AddAsTablePerConcreteClassEntity(typeof (Inherited1));
 
-			inspector.Executing(x => x.AddAsTablePerClassHierarchyEntity(typeof(Inherited1))).Throws<MappingException>();
+			Executing.This(() =>
+			               {
+			               	inspector.AddAsTablePerClassHierarchyEntity(typeof (Inherited1));
+			               	inspector.IsTablePerConcreteClass(typeof (Inherited1));
+			               }).Should().Throw<MappingException>();
 		}
 
 		[Test]
 		public void WhenRegisteredAsUnionSubclassThenCantRegisterAsJoinedSubclass()
 		{
 			var inspector = new ExplicitlyDeclaredModel();
-			inspector.AddAsRootEntity(typeof(MyClass));
-			inspector.AddAsTablePerConcreteClassEntity(typeof(Inherited1));
+			inspector.AddAsRootEntity(typeof (MyClass));
+			inspector.AddAsTablePerConcreteClassEntity(typeof (Inherited1));
 
-			inspector.Executing(x => x.AddAsTablePerClassEntity(typeof(Inherited1))).Throws<MappingException>();
+			Executing.This(() =>
+			               {
+			               	inspector.AddAsTablePerClassEntity(typeof (Inherited1));
+			               	inspector.IsTablePerConcreteClass(typeof (Inherited1));
+			               }).Should().Throw<MappingException>();
 		}
 
 		[Test]

Added: trunk/nhibernate/src/NHibernate.Test/MappingByCode/MixAutomapping/CallCustomConditions.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/MixAutomapping/CallCustomConditions.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/MixAutomapping/CallCustomConditions.cs	2011-05-08 22:59:17 UTC (rev 5800)
@@ -0,0 +1,68 @@
+using System;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+using SharpTestsEx;
+
+namespace NHibernate.Test.MappingByCode.MixAutomapping
+{
+	public class CallCustomConditions
+	{
+		public enum ActivityType
+		{
+			Form = 1,
+			Custom = 2,
+			Email = 3
+		}
+
+		private class Activity : Entity
+		{
+			public virtual string Title { get; set; }
+		}
+
+		private interface IEntity<T>
+		{
+			T Id { get; }
+		}
+
+		private class Entity : IEntity<Guid>
+		{
+			#region IEntity<Guid> Members
+
+			public virtual Guid Id { get; private set; }
+
+			#endregion
+		}
+
+		private class FormActivity : Activity { }
+
+		[Test]
+		public void WhenCustomizeConditionsThenUseCustomConditionsToRecognizeRootEntities()
+		{
+			System.Type baseEntityType = typeof(Entity);
+			var inspector = new SimpleModelInspector();
+			inspector.IsEntity((t, declared) => baseEntityType.IsAssignableFrom(t) && baseEntityType != t && !t.IsInterface);
+			inspector.IsRootEntity((t, declared) => baseEntityType.Equals(t.BaseType));
+
+			var mapper = new ModelMapper(inspector);
+			mapper.Class<Entity>(map => map.Id(x => x.Id,
+																				 m =>
+																				 {
+																					 m.Generator(Generators.Guid);
+																					 m.Column("ID");
+																				 }));
+
+			mapper.Class<Activity>(map =>
+			{
+				map.Discriminator(dm =>
+				{
+					dm.Column("DISCRIMINATOR_TYPE");
+					dm.NotNullable(true);
+				});
+				map.DiscriminatorValue(0);
+			});
+			mapper.Subclass<FormActivity>(map => map.DiscriminatorValue(1));
+
+			mapper.Executing(m=> m.CompileMappingFor(new[] { typeof(Activity), typeof(FormActivity) })).NotThrows();
+		}
+	}
+}
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-05-06 14:14:41 UTC (rev 5799)
+++ trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-05-08 22:59:17 UTC (rev 5800)
@@ -585,6 +585,7 @@
     <Compile Include="MappingByCode\MappersTests\UnionSubclassMapperTests\TablesSincronizationTests.cs" />
     <Compile Include="MappingByCode\MixAutomapping\ArrayCollectionTests.cs" />
     <Compile Include="MappingByCode\MixAutomapping\BagCollectionTests.cs" />
+    <Compile Include="MappingByCode\MixAutomapping\CallCustomConditions.cs" />
     <Compile Include="MappingByCode\MixAutomapping\Compone...
 
[truncated message content]

[Nhibernate-commit] SF.net SVN: nhibernate:[5799] trunk/nhibernate/src/NHibernate/Mapping/ ByCode

[<fab...@us...>]

Revision: 5799
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5799&view=rev
Author:   fabiomaulo
Date:     2011-05-06 14:14:41 +0000 (Fri, 06 May 2011)

Log Message:
-----------
cleaned public API

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/CacheInclude.cs
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/CacheUsage.cs
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/CollectionFetchMode.cs
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/FetchKind.cs

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/CacheInclude.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/CacheInclude.cs	2011-05-06 12:28:17 UTC (rev 5798)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/CacheInclude.cs	2011-05-06 14:14:41 UTC (rev 5799)
@@ -7,13 +7,13 @@
 		public static CacheInclude All = new AllCacheInclude();
 		public static CacheInclude NonLazy = new NonLazyCacheInclude();
 
-		public abstract HbmCacheInclude ToHbm();
+		internal abstract HbmCacheInclude ToHbm();
 
 		#region Nested type: AllCacheInclude
 
 		public class AllCacheInclude : CacheInclude
 		{
-			public override HbmCacheInclude ToHbm()
+			internal override HbmCacheInclude ToHbm()
 			{
 				return HbmCacheInclude.All;
 			}
@@ -25,7 +25,7 @@
 
 		public class NonLazyCacheInclude : CacheInclude
 		{
-			public override HbmCacheInclude ToHbm()
+			internal override HbmCacheInclude ToHbm()
 			{
 				return HbmCacheInclude.NonLazy;
 			}

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/CacheUsage.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/CacheUsage.cs	2011-05-06 12:28:17 UTC (rev 5798)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/CacheUsage.cs	2011-05-06 14:14:41 UTC (rev 5799)
@@ -9,13 +9,13 @@
 		public static CacheUsage NonstrictReadWrite = new NonstrictReadWriteUsage();
 		public static CacheUsage Transactional = new TransactionalUsage();
 
-		public abstract HbmCacheUsage ToHbm();
+		internal abstract HbmCacheUsage ToHbm();
 
 		#region Nested type: NonstrictReadWriteUsage
 
 		private class NonstrictReadWriteUsage : CacheUsage
 		{
-			public override HbmCacheUsage ToHbm()
+			internal override HbmCacheUsage ToHbm()
 			{
 				return HbmCacheUsage.NonstrictReadWrite;
 			}
@@ -27,7 +27,7 @@
 
 		private class ReadOnlyUsage : CacheUsage
 		{
-			public override HbmCacheUsage ToHbm()
+			internal override HbmCacheUsage ToHbm()
 			{
 				return HbmCacheUsage.ReadOnly;
 			}
@@ -39,7 +39,7 @@
 
 		private class ReadWriteUsage : CacheUsage
 		{
-			public override HbmCacheUsage ToHbm()
+			internal override HbmCacheUsage ToHbm()
 			{
 				return HbmCacheUsage.ReadWrite;
 			}
@@ -51,7 +51,7 @@
 
 		private class TransactionalUsage : CacheUsage
 		{
-			public override HbmCacheUsage ToHbm()
+			internal override HbmCacheUsage ToHbm()
 			{
 				return HbmCacheUsage.Transactional;
 			}

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/CollectionFetchMode.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/CollectionFetchMode.cs	2011-05-06 12:28:17 UTC (rev 5798)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/CollectionFetchMode.cs	2011-05-06 14:14:41 UTC (rev 5799)
@@ -8,13 +8,13 @@
 		public static CollectionFetchMode Join = new JoinFetchMode();
 		public static CollectionFetchMode Subselect = new SubselectFetchMode();
 
-		public abstract HbmCollectionFetchMode ToHbm();
+		internal abstract HbmCollectionFetchMode ToHbm();
 
 		#region Nested type: JoinFetchMode
 
 		private class JoinFetchMode : CollectionFetchMode
 		{
-			public override HbmCollectionFetchMode ToHbm()
+			internal override HbmCollectionFetchMode ToHbm()
 			{
 				return HbmCollectionFetchMode.Join;
 			}
@@ -26,7 +26,7 @@
 
 		private class SelectFetchMode : CollectionFetchMode
 		{
-			public override HbmCollectionFetchMode ToHbm()
+			internal override HbmCollectionFetchMode ToHbm()
 			{
 				return HbmCollectionFetchMode.Select;
 			}
@@ -38,7 +38,7 @@
 
 		private class SubselectFetchMode : CollectionFetchMode
 		{
-			public override HbmCollectionFetchMode ToHbm()
+			internal override HbmCollectionFetchMode ToHbm()
 			{
 				return HbmCollectionFetchMode.Subselect;
 			}

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/FetchKind.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/FetchKind.cs	2011-05-06 12:28:17 UTC (rev 5798)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/FetchKind.cs	2011-05-06 14:14:41 UTC (rev 5799)
@@ -7,19 +7,19 @@
 		public static FetchKind Select = new SelectFetchMode();
 		public static FetchKind Join = new JoinFetchMode();
 
-		public abstract HbmFetchMode ToHbm();
-		public abstract HbmJoinFetch ToHbmJoinFetch();
+		internal abstract HbmFetchMode ToHbm();
+		internal abstract HbmJoinFetch ToHbmJoinFetch();
 
 		#region Nested type: JoinFetchMode
 
 		private class JoinFetchMode : FetchKind
 		{
-			public override HbmFetchMode ToHbm()
+			internal override HbmFetchMode ToHbm()
 			{
 				return HbmFetchMode.Join;
 			}
 
-			public override HbmJoinFetch ToHbmJoinFetch()
+			internal override HbmJoinFetch ToHbmJoinFetch()
 			{
 				return HbmJoinFetch.Join;
 			}
@@ -31,12 +31,12 @@
 
 		private class SelectFetchMode : FetchKind
 		{
-			public override HbmFetchMode ToHbm()
+			internal override HbmFetchMode ToHbm()
 			{
 				return HbmFetchMode.Select;
 			}
 
-			public override HbmJoinFetch ToHbmJoinFetch()
+			internal override HbmJoinFetch ToHbmJoinFetch()
 			{
 				return HbmJoinFetch.Select;
 			}


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5798] trunk/nhibernate/src/NHibernate

[<fab...@us...>]

Revision: 5798
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5798&view=rev
Author:   fabiomaulo
Date:     2011-05-06 12:28:17 +0000 (Fri, 06 May 2011)

Log Message:
-----------
Support of Generated for properties

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/IPropertyMapper.cs
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/KeyPropertyMapper.cs
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/PropertyMapper.cs
    trunk/nhibernate/src/NHibernate/NHibernate.csproj

Added Paths:
-----------
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/PropertyGeneration.cs

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/IPropertyMapper.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/IPropertyMapper.cs	2011-05-03 21:33:56 UTC (rev 5797)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/IPropertyMapper.cs	2011-05-06 12:28:17 UTC (rev 5798)
@@ -19,5 +19,6 @@
 		void Update(bool consideredInUpdateQuery);
 		void Insert(bool consideredInInsertQuery);
 		void Lazy(bool isLazy);
+		void Generated(PropertyGeneration generation);
 	}
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/KeyPropertyMapper.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/KeyPropertyMapper.cs	2011-05-03 21:33:56 UTC (rev 5797)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/KeyPropertyMapper.cs	2011-05-06 12:28:17 UTC (rev 5798)
@@ -215,6 +215,11 @@
 			// lazy is not supported by HbmKeyProperty
 		}
 
+		public void Generated(PropertyGeneration generation)
+		{
+			// generated is not supported by HbmKeyProperty
+		}
+
 		private bool ColumnTagIsRequired(HbmColumn hbm)
 		{
 			return hbm.precision != null || hbm.scale != null || hbm.notnull || hbm.unique

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/PropertyMapper.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/PropertyMapper.cs	2011-05-03 21:33:56 UTC (rev 5797)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/PropertyMapper.cs	2011-05-06 12:28:17 UTC (rev 5798)
@@ -259,6 +259,15 @@
 			propertyMapping.lazy = isLazy;
 		}
 
+		public void Generated(PropertyGeneration generation)
+		{
+			if (generation == null)
+			{
+				return;
+			}
+			propertyMapping.generated = generation.ToHbm();
+		}
+
 		private void ResetColumnPlainValues()
 		{
 			propertyMapping.column = null;

Added: trunk/nhibernate/src/NHibernate/Mapping/ByCode/PropertyGeneration.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/PropertyGeneration.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/PropertyGeneration.cs	2011-05-06 12:28:17 UTC (rev 5798)
@@ -0,0 +1,37 @@
+using NHibernate.Cfg.MappingSchema;
+
+namespace NHibernate.Mapping.ByCode
+{
+	public abstract class PropertyGeneration
+	{
+		public static PropertyGeneration Never = new NeverPropertyGeneration();
+		public static PropertyGeneration Insert = new InsertPropertyGeneration();
+		public static PropertyGeneration Always = new AlwaysPropertyGeneration();
+
+		internal abstract HbmPropertyGeneration ToHbm();
+
+		public class AlwaysPropertyGeneration : PropertyGeneration
+		{
+			internal override HbmPropertyGeneration ToHbm()
+			{
+				return HbmPropertyGeneration.Always;
+			}
+		}
+
+		public class InsertPropertyGeneration : PropertyGeneration
+		{
+			internal override HbmPropertyGeneration ToHbm()
+			{
+				return HbmPropertyGeneration.Insert;
+			}
+		}
+
+		public class NeverPropertyGeneration : PropertyGeneration
+		{
+			internal override HbmPropertyGeneration ToHbm()
+			{
+				return HbmPropertyGeneration.Never;
+			}
+		}
+	}
+}
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate/NHibernate.csproj
===================================================================
--- trunk/nhibernate/src/NHibernate/NHibernate.csproj	2011-05-03 21:33:56 UTC (rev 5797)
+++ trunk/nhibernate/src/NHibernate/NHibernate.csproj	2011-05-06 12:28:17 UTC (rev 5798)
@@ -304,6 +304,7 @@
     <Compile Include="Mapping\ByCode\Impl\CustomizersImpl\ComposedIdCustomizer.cs" />
     <Compile Include="Mapping\ByCode\Impl\CustomizersImpl\DynamicComponentCustomizer.cs" />
     <Compile Include="Mapping\ByCode\Impl\DynamicComponentMapper.cs" />
+    <Compile Include="Mapping\ByCode\PropertyGeneration.cs" />
     <Compile Include="Mapping\ByCode\PropertyToField.cs" />
     <Compile Include="Mapping\ByCode\SimpleModelInspector.cs" />
     <Compile Include="Mapping\ByCode\ExplicitlyDeclaredModel.cs" />


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5797] trunk/nhibernate/src/NHibernate.Test/Hql/Ast/ LimitClauseFixture.cs

[<fab...@us...>]

Revision: 5797
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5797&view=rev
Author:   fabiomaulo
Date:     2011-05-03 21:33:56 +0000 (Tue, 03 May 2011)

Log Message:
-----------
Tests for unsupported feature for Skip and Take using parameters instead values

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate.Test/Hql/Ast/LimitClauseFixture.cs

Modified: trunk/nhibernate/src/NHibernate.Test/Hql/Ast/LimitClauseFixture.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/Hql/Ast/LimitClauseFixture.cs	2011-05-03 11:20:54 UTC (rev 5796)
+++ trunk/nhibernate/src/NHibernate.Test/Hql/Ast/LimitClauseFixture.cs	2011-05-03 21:33:56 UTC (rev 5797)
@@ -68,6 +68,20 @@
             s.Close();
         }
 
+				[Test, Ignore("Not supported yet.")]
+				public void SkipWithParameter()
+				{
+					ISession s = OpenSession();
+					ITransaction txn = s.BeginTransaction();
+
+					var actual = s.CreateQuery("from Human h order by h.bodyWeight skip :jump").SetInt32("jump", 2).List<Human>().Select(h => h.BodyWeight).ToArray();
+					var expected = new[] { 10, 15, 20 };
+					CollectionAssert.AreEqual(expected, actual);
+
+					txn.Commit();
+					s.Close();
+				}
+
         [Test]
         public void Take()
         {
@@ -82,6 +96,20 @@
             s.Close();
         }
 
+				[Test, Ignore("Not supported yet.")]
+				public void TakeWithParameter()
+				{
+					ISession s = OpenSession();
+					ITransaction txn = s.BeginTransaction();
+
+					var actual = s.CreateQuery("from Human h order by h.bodyWeight take :jump").SetInt32("jump", 2).List<Human>().Select(h => h.BodyWeight).ToArray();
+					var expected = new[] { 5, 6 };
+					CollectionAssert.AreEqual(expected, actual);
+
+					txn.Commit();
+					s.Close();
+				}
+
         [Test]
         public void SkipTake()
         {
@@ -96,6 +124,22 @@
             s.Close();
         }
 
+				[Test, Ignore("Not supported yet.")]
+				public void SkipTakeWithParameter()
+				{
+					ISession s = OpenSession();
+					ITransaction txn = s.BeginTransaction();
+
+					var actual = s.CreateQuery("from Human h order by h.bodyWeight skip :pSkip take :pTake")
+						.SetInt32("pSkip", 1)
+						.SetInt32("pTake", 3).List<Human>().Select(h => h.BodyWeight).ToArray();
+					var expected = new[] { 6, 10, 15 };
+					CollectionAssert.AreEqual(expected, actual);
+
+					txn.Commit();
+					s.Close();
+				}
+
         [Test]
         public void TakeSkip()
         {


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5796] trunk/nhibernate/src/NHibernate.Test

[<fab...@us...>]

Revision: 5796
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5796&view=rev
Author:   fabiomaulo
Date:     2011-05-03 11:20:54 +0000 (Tue, 03 May 2011)

Log Message:
-----------
Demonstration NH-2587 was fixed

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj

Added Paths:
-----------
    trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2587/
    trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2587/CachingWithLinq.cs

Added: trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2587/CachingWithLinq.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2587/CachingWithLinq.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2587/CachingWithLinq.cs	2011-05-03 11:20:54 UTC (rev 5796)
@@ -0,0 +1,117 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NHibernate.Cache;
+using NHibernate.Cfg;
+using NHibernate.Cfg.MappingSchema;
+using NHibernate.Linq;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+
+namespace NHibernate.Test.NHSpecificTest.NH2587
+{
+	public class Foo
+	{
+		public Foo()
+		{
+			Bars = new List<Bar>();
+		}
+		public virtual Guid Id { get; set; }
+		public virtual ICollection<Bar> Bars { get; set; }
+	}
+
+	public class Bar
+	{
+		public virtual Guid Id { get; set; }
+		public virtual Foo Foo { get; set; }
+	}
+
+	public class CachingWithLinq : TestCaseMappingByCode
+	{
+		protected override HbmMapping GetMappings()
+		{
+			var mapper = new ModelMapper();
+			mapper.BeforeMapClass += (inspector, type, map) => map.Id(x=> x.Generator(Generators.GuidComb));
+			mapper.Class<Foo>(mc =>
+			                  {
+													mc.Id(x => x.Id);
+													mc.Bag(x => x.Bars, map =>
+													                    {
+													                    	map.Inverse(true);
+													                    	map.Cascade(Mapping.ByCode.Cascade.All);
+																								map.Key(km =>
+																								        {
+																								        	km.Column("FooId");
+																													km.OnDelete(OnDeleteAction.Cascade);
+																								        });
+													                    }, rel => rel.OneToMany());
+			                  });
+			mapper.Class<Bar>(mc =>
+			                  {
+													mc.Id(x => x.Id);
+			                  	mc.ManyToOne(x=> x.Foo, map=> map.Column("FooId"));
+			                  });
+			var mappings = mapper.CompileMappingForAllExplicitAddedEntities();
+			return mappings;
+		}
+
+		protected override void Configure(Cfg.Configuration configuration)
+		{
+			configuration.Cache(x =>
+			                    {
+														x.Provider<HashtableCacheProvider>();
+														x.UseQueryCache = true;
+			                    });
+		}
+
+		public class Scenario: IDisposable
+		{
+			private readonly ISessionFactory factory;
+
+			public Scenario(ISessionFactory factory)
+			{
+				this.factory = factory;
+				using (ISession session = factory.OpenSession())
+				using (ITransaction tx = session.BeginTransaction())
+				{
+					var foo1 = new Foo();
+					foo1.Bars.Add(new Bar {Foo = foo1});
+					foo1.Bars.Add(new Bar { Foo = foo1 });
+					var foo2 = new Foo();
+					foo2.Bars.Add(new Bar { Foo = foo2 });
+
+					session.Persist(foo1);
+					session.Persist(foo2);
+					tx.Commit();
+				}
+			}
+
+			public void Dispose()
+			{
+				using (ISession session = factory.OpenSession())
+				using (ITransaction tx = session.BeginTransaction())
+				{
+					session.CreateQuery("delete from Foo").ExecuteUpdate();
+					tx.Commit();
+				}
+			}
+		}
+		[Test]
+		public void TestMethod1()
+		{
+			using (new Scenario(Sfi))
+			{
+				// The test provided is only about Not-Throw
+				using (ISession session = OpenSession())
+				using (ITransaction transaction = session.BeginTransaction())
+				{
+
+					session.Query<Foo>().Cacheable().ToList();
+					session.Query<Bar>().Cacheable().ToList();
+					session.Query<Foo>().Cacheable().Fetch(x => x.Bars).ToList();
+					session.Query<Bar>().Cacheable().Fetch(x => x.Foo).ToList();
+				}
+			}
+		}
+	}
+}
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-05-02 15:41:52 UTC (rev 5795)
+++ trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-05-03 11:20:54 UTC (rev 5796)
@@ -804,6 +804,7 @@
     <Compile Include="NHSpecificTest\NH2583\MassTestingThreeOrTreesSideBySideFixture.cs" />
     <Compile Include="NHSpecificTest\NH2583\MassTestingTwoOrTreesSideBySideFixture.cs" />
     <Compile Include="NHSpecificTest\NH2583\SelfJoinTestFixture.cs" />
+    <Compile Include="NHSpecificTest\NH2587\CachingWithLinq.cs" />
     <Compile Include="NHSpecificTest\NH2603\Fixture.cs" />
     <Compile Include="NHSpecificTest\NH2603\Model.cs" />
     <Compile Include="NHSpecificTest\NH2632\Domain.cs" />


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5795] trunk/nhibernate/src/NHibernate

[<fab...@us...>]

Revision: 5795
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5795&view=rev
Author:   fabiomaulo
Date:     2011-05-02 15:41:52 +0000 (Mon, 02 May 2011)

Log Message:
-----------
Fixed NH-2686

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Linq/ResultTransformer.cs
    trunk/nhibernate/src/NHibernate/Transform/AliasToBeanConstructorResultTransformer.cs
    trunk/nhibernate/src/NHibernate/Transform/AliasToBeanResultTransformer.cs
    trunk/nhibernate/src/NHibernate/Transform/AliasToEntityMapResultTransformer.cs
    trunk/nhibernate/src/NHibernate/Transform/DistinctRootEntityResultTransformer.cs
    trunk/nhibernate/src/NHibernate/Transform/PassThroughResultTransformer.cs
    trunk/nhibernate/src/NHibernate/Transform/RootEntityResultTransformer.cs
    trunk/nhibernate/src/NHibernate/Transform/ToListResultTransformer.cs
    trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj

Added Paths:
-----------
    trunk/nhibernate/src/NHibernate.Test/TransformTests/ImplementationOfEqualityTests.cs

Modified: trunk/nhibernate/src/NHibernate/Linq/ResultTransformer.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Linq/ResultTransformer.cs	2011-05-02 14:26:59 UTC (rev 5794)
+++ trunk/nhibernate/src/NHibernate/Linq/ResultTransformer.cs	2011-05-02 15:41:52 UTC (rev 5795)
@@ -57,5 +57,33 @@
             var list = new ArrayList {transformResult};
             return list;
         }
+
+    	public bool Equals(ResultTransformer other)
+    	{
+    		if (ReferenceEquals(null, other))
+    		{
+    			return false;
+    		}
+    		if (ReferenceEquals(this, other))
+    		{
+    			return true;
+    		}
+    		return Equals(other._listTransformation, _listTransformation) && Equals(other._itemTransformation, _itemTransformation);
+    	}
+
+    	public override bool Equals(object obj)
+    	{
+				return Equals(obj as ResultTransformer);
+    	}
+
+    	public override int GetHashCode()
+    	{
+    		unchecked
+    		{
+    			var lt = (_listTransformation != null ? _listTransformation.GetHashCode() : 0);
+    			var it = (_itemTransformation != null ? _itemTransformation.GetHashCode() : 0);
+    			return (lt * 397) ^ (it * 17);
+    		}
+    	}
     }
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate/Transform/AliasToBeanConstructorResultTransformer.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Transform/AliasToBeanConstructorResultTransformer.cs	2011-05-02 14:26:59 UTC (rev 5794)
+++ trunk/nhibernate/src/NHibernate/Transform/AliasToBeanConstructorResultTransformer.cs	2011-05-02 15:41:52 UTC (rev 5795)
@@ -7,10 +7,14 @@
 	[Serializable]
 	public class AliasToBeanConstructorResultTransformer : IResultTransformer
 	{
-		private ConstructorInfo constructor;
+		private readonly ConstructorInfo constructor;
 
 		public AliasToBeanConstructorResultTransformer(ConstructorInfo constructor)
 		{
+			if (constructor == null)
+			{
+				throw new ArgumentNullException("constructor");
+			}
 			this.constructor = constructor;
 		}
 
@@ -33,5 +37,28 @@
 		{
 			return collection;
 		}
+
+		public bool Equals(AliasToBeanConstructorResultTransformer other)
+		{
+			if (ReferenceEquals(null, other))
+			{
+				return false;
+			}
+			if (ReferenceEquals(this, other))
+			{
+				return true;
+			}
+			return Equals(other.constructor, constructor);
+		}
+
+		public override bool Equals(object obj)
+		{
+			return Equals(obj as AliasToBeanConstructorResultTransformer);
+		}
+
+		public override int GetHashCode()
+		{
+			return constructor.GetHashCode();
+		}
 	}
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate/Transform/AliasToBeanResultTransformer.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Transform/AliasToBeanResultTransformer.cs	2011-05-02 14:26:59 UTC (rev 5794)
+++ trunk/nhibernate/src/NHibernate/Transform/AliasToBeanResultTransformer.cs	2011-05-02 15:41:52 UTC (rev 5795)
@@ -111,5 +111,28 @@
 		{
 			return collection;
 		}
+
+		public override bool Equals(object obj)
+		{
+			return Equals(obj as AliasToBeanResultTransformer);
+		}
+
+		public bool Equals(AliasToBeanResultTransformer other)
+		{
+			if (ReferenceEquals(null, other))
+			{
+				return false;
+			}
+			if (ReferenceEquals(this, other))
+			{
+				return true;
+			}
+			return Equals(other.resultClass, resultClass);
+		}
+
+		public override int GetHashCode()
+		{
+			return resultClass.GetHashCode();
+		}
 	}
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate/Transform/AliasToEntityMapResultTransformer.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Transform/AliasToEntityMapResultTransformer.cs	2011-05-02 14:26:59 UTC (rev 5794)
+++ trunk/nhibernate/src/NHibernate/Transform/AliasToEntityMapResultTransformer.cs	2011-05-02 15:41:52 UTC (rev 5795)
@@ -6,6 +6,8 @@
 	[Serializable]
 	public class AliasToEntityMapResultTransformer : IResultTransformer
 	{
+		private static readonly object Hasher = new object();
+
 		public object TransformTuple(object[] tuple, string[] aliases)
 		{
 			IDictionary result = new Hashtable();
@@ -26,5 +28,19 @@
 		{
 			return collection;
 		}
+
+		public override bool Equals(object obj)
+		{
+			if (obj == null)
+			{
+				return false;
+			}
+			return obj.GetHashCode() == Hasher.GetHashCode();
+		}
+
+		public override int GetHashCode()
+		{
+			return Hasher.GetHashCode();
+		}
 	}
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate/Transform/DistinctRootEntityResultTransformer.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Transform/DistinctRootEntityResultTransformer.cs	2011-05-02 14:26:59 UTC (rev 5794)
+++ trunk/nhibernate/src/NHibernate/Transform/DistinctRootEntityResultTransformer.cs	2011-05-02 15:41:52 UTC (rev 5795)
@@ -10,6 +10,7 @@
 	public class DistinctRootEntityResultTransformer : IResultTransformer
 	{
 		private static readonly IInternalLogger log = LoggerProvider.LoggerFor(typeof(DistinctRootEntityResultTransformer));
+		private static readonly object Hasher = new object();
 
 		internal sealed class Identity
 		{
@@ -58,5 +59,19 @@
 			}
 			return result;
 		}
+
+		public override bool Equals(object obj)
+		{
+			if (obj == null)
+			{
+				return false;
+			}
+			return obj.GetHashCode() == Hasher.GetHashCode();
+		}
+
+		public override int GetHashCode()
+		{
+			return Hasher.GetHashCode();
+		}
 	}
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate/Transform/PassThroughResultTransformer.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Transform/PassThroughResultTransformer.cs	2011-05-02 14:26:59 UTC (rev 5794)
+++ trunk/nhibernate/src/NHibernate/Transform/PassThroughResultTransformer.cs	2011-05-02 15:41:52 UTC (rev 5795)
@@ -6,6 +6,8 @@
 	[Serializable]
 	public class PassThroughResultTransformer : IResultTransformer
 	{
+		private static readonly object Hasher = new object();
+
 		#region IResultTransformer Members
 
 		public object TransformTuple(object[] tuple, string[] aliases)
@@ -19,5 +21,19 @@
 		}
 
 		#endregion
+
+		public override bool Equals(object obj)
+		{
+			if (obj == null)
+			{
+				return false;
+			}
+			return obj.GetHashCode() == Hasher.GetHashCode();
+		}
+
+		public override int GetHashCode()
+		{
+			return Hasher.GetHashCode();
+		}
 	}
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate/Transform/RootEntityResultTransformer.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Transform/RootEntityResultTransformer.cs	2011-05-02 14:26:59 UTC (rev 5794)
+++ trunk/nhibernate/src/NHibernate/Transform/RootEntityResultTransformer.cs	2011-05-02 15:41:52 UTC (rev 5795)
@@ -6,6 +6,8 @@
 	[Serializable]
 	public class RootEntityResultTransformer : IResultTransformer
 	{
+		private static readonly object Hasher = new object();
+
 		public object TransformTuple(object[] tuple, string[] aliases)
 		{
 			return tuple[tuple.Length - 1];
@@ -15,5 +17,19 @@
 		{
 			return collection;
 		}
+
+		public override bool Equals(object obj)
+		{
+			if (obj == null)
+			{
+				return false;
+			}
+			return obj.GetHashCode() == Hasher.GetHashCode();
+		}
+
+		public override int GetHashCode()
+		{
+			return Hasher.GetHashCode();
+		}
 	}
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate/Transform/ToListResultTransformer.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Transform/ToListResultTransformer.cs	2011-05-02 14:26:59 UTC (rev 5794)
+++ trunk/nhibernate/src/NHibernate/Transform/ToListResultTransformer.cs	2011-05-02 15:41:52 UTC (rev 5795)
@@ -10,6 +10,8 @@
 	[Serializable]
 	public class ToListResultTransformer : IResultTransformer
 	{
+		private static readonly object Hasher = new object();
+
 		public object TransformTuple(object[] tuple, string[] aliases)
 		{
 			return new ArrayList(tuple);
@@ -19,5 +21,19 @@
 		{
 			return list;
 		}
+
+		public override bool Equals(object obj)
+		{
+			if (obj == null)
+			{
+				return false;
+			}
+			return obj.GetHashCode() == Hasher.GetHashCode();
+		}
+
+		public override int GetHashCode()
+		{
+			return Hasher.GetHashCode();
+		}
 	}
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-05-02 14:26:59 UTC (rev 5794)
+++ trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-05-02 15:41:52 UTC (rev 5795)
@@ -856,6 +856,7 @@
     <Compile Include="TestDialect.cs" />
     <Compile Include="TestDialects\PostgreSQL82TestDialect.cs" />
     <Compile Include="TestDialects\SQLiteTestDialect.cs" />
+    <Compile Include="TransformTests\ImplementationOfEqualityTests.cs" />
     <Compile Include="TypesTest\CharClass.cs" />
     <Compile Include="TypesTest\CharClassFixture.cs" />
     <Compile Include="TypesTest\DateTimeClass.cs" />

Added: trunk/nhibernate/src/NHibernate.Test/TransformTests/ImplementationOfEqualityTests.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/TransformTests/ImplementationOfEqualityTests.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/TransformTests/ImplementationOfEqualityTests.cs	2011-05-02 15:41:52 UTC (rev 5795)
@@ -0,0 +1,95 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using NHibernate.Linq;
+using NHibernate.Transform;
+using NUnit.Framework;
+using SharpTestsEx;
+
+namespace NHibernate.Test.TransformTests
+{
+	public class ImplementationOfEqualityTests
+	{
+		private readonly IEnumerable<System.Type> transformerTypes = typeof(IResultTransformer).Assembly.GetTypes().Where(t => typeof(IResultTransformer).IsAssignableFrom(t) && t.IsClass).ToList();
+
+		[Test]
+		public void AllEmbeddedTransformersOverridesEqualsAndGetHashCode()
+		{
+			foreach (var transformerType in transformerTypes)
+			{
+				var declaredMethods = transformerType.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
+				declaredMethods.Select(x => x.Name).Should("The type "+transformerType+" does not implement Equals").Contain("Equals");
+				declaredMethods.Select(x => x.Name).Should("The type " + transformerType + " does not implement GetHashCode").Contain("GetHashCode");
+			}
+		}
+
+		[Test]
+		public void AllEmbeddedTransformersWithDefaultCtorHasEqualityWorkingAsSingleton()
+		{
+			foreach (var transformerType in transformerTypes)
+			{
+				IResultTransformer transformer1;
+				try
+				{
+					transformer1 = (IResultTransformer)Activator.CreateInstance(transformerType);
+				}
+				catch (Exception e)
+				{
+					// The transformer does not have default ctor
+					Console.WriteLine(transformerType);
+					Console.WriteLine(e);
+					continue;
+				}
+				var transformer2= (IResultTransformer)Activator.CreateInstance(transformerType);
+				transformer1.Should().Be.EqualTo(transformer2);
+				transformer1.GetHashCode().Should().Be.EqualTo(transformer2.GetHashCode());
+			}
+		}
+
+		[Test]
+		public void AliasToBeanResultTransformer_ShouldHaveEqualityBasedOnCtorParameter()
+		{
+			var transformer1 = new AliasToBeanResultTransformer(typeof(object));
+			var transformer2 = new AliasToBeanResultTransformer(typeof(object));
+			transformer1.Should().Be.EqualTo(transformer2);
+			transformer1.GetHashCode().Should().Be.EqualTo(transformer2.GetHashCode());
+
+			var transformer3 = new AliasToBeanResultTransformer(typeof(int));
+			transformer1.Should().Not.Be.EqualTo(transformer3);
+			transformer1.GetHashCode().Should().Not.Be.EqualTo(transformer3.GetHashCode());
+		}
+
+		[Test]
+		public void AliasToBeanConstructorResultTransformer_ShouldHaveEqualityBasedOnCtorParameter()
+		{
+			var emptyCtor = new System.Type[0];
+			var transformer1 = new AliasToBeanConstructorResultTransformer(typeof(object).GetConstructor(emptyCtor));
+			var transformer2 = new AliasToBeanConstructorResultTransformer(typeof(object).GetConstructor(emptyCtor));
+			transformer1.Should().Be.EqualTo(transformer2);
+			transformer1.GetHashCode().Should().Be.EqualTo(transformer2.GetHashCode());
+
+			var transformer3 = new AliasToBeanConstructorResultTransformer(typeof(ImplementationOfEqualityTests).GetConstructor(emptyCtor));
+			transformer1.Should().Not.Be.EqualTo(transformer3);
+			transformer1.GetHashCode().Should().Not.Be.EqualTo(transformer3.GetHashCode());
+		}
+
+		public delegate void DoNothingDelegate();
+		public delegate void DoNothingDelegate1();
+		[Test]
+		public void LinqResultTransformer_ShouldHaveEqualityBasedOnCtorParameter()
+		{
+			DoNothingDelegate d1 = () => { };
+			DoNothingDelegate d2 = () => { };
+			var transformer1 = new ResultTransformer(d1, d2);
+			var transformer2 = new ResultTransformer(d1, d2);
+			transformer1.Should().Be.EqualTo(transformer2);
+			transformer1.GetHashCode().Should().Be.EqualTo(transformer2.GetHashCode());
+
+			DoNothingDelegate1 d3 = () => { };
+			var transformer3 = new ResultTransformer(d1, d3);
+			transformer1.Should().Not.Be.EqualTo(transformer3);
+			transformer1.GetHashCode().Should().Not.Be.EqualTo(transformer3.GetHashCode());
+		}
+	}
+}
\ No newline at end of file


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5794] trunk/nhibernate/src/NHibernate

[<fab...@us...>]

Revision: 5794
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5794&view=rev
Author:   fabiomaulo
Date:     2011-05-02 14:26:59 +0000 (Mon, 02 May 2011)

Log Message:
-----------
Fix NH-2685 and any other possible not safe call to the logger

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Logging.cs
    trunk/nhibernate/src/NHibernate.Test/Logging/Log4NetLoggerTest.cs

Modified: trunk/nhibernate/src/NHibernate/Logging.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Logging.cs	2011-05-02 14:08:59 UTC (rev 5793)
+++ trunk/nhibernate/src/NHibernate/Logging.cs	2011-05-02 14:26:59 UTC (rev 5794)
@@ -374,72 +374,86 @@
 
 		public void Error(object message)
 		{
-			ErrorDelegate(logger, message);
+			if (IsErrorEnabled)
+				ErrorDelegate(logger, message);
 		}
 
 		public void Error(object message, Exception exception)
 		{
-			ErrorExceptionDelegate(logger,message,exception);
+			if (IsErrorEnabled)
+				ErrorExceptionDelegate(logger, message, exception);
 		}
 
 		public void ErrorFormat(string format, params object[] args)
 		{
-			ErrorFormatDelegate(logger, format, args);
+			if (IsErrorEnabled)
+				ErrorFormatDelegate(logger, format, args);
 		}
 
 		public void Fatal(object message)
 		{
-			FatalDelegate(logger, message);
+			if (IsFatalEnabled)
+				FatalDelegate(logger, message);
 		}
 
 		public void Fatal(object message, Exception exception)
 		{
-			FatalExceptionDelegate(logger,message,exception);
+			if (IsFatalEnabled)
+				FatalExceptionDelegate(logger, message, exception);
 		}
 
 		public void Debug(object message)
 		{
-			DebugDelegate(logger, message);
+			if (IsDebugEnabled)
+				DebugDelegate(logger, message);
 		}
 
 		public void Debug(object message, Exception exception)
 		{
-			DebugExceptionDelegate(logger, message, exception);
+			if (IsDebugEnabled)
+				DebugExceptionDelegate(logger, message, exception);
 		}
 
 		public void DebugFormat(string format, params object[] args)
 		{
-			DebugFormatDelegate(logger, format, args);
+			if (IsDebugEnabled)
+				DebugFormatDelegate(logger, format, args);
 		}
 
 		public void Info(object message)
 		{
-			InfoDelegate(logger, message);
+			if (IsInfoEnabled)
+				InfoDelegate(logger, message);
 		}
 
 		public void Info(object message, Exception exception)
 		{
-			InfoExceptionDelegate(logger, message, exception);
+			if (IsInfoEnabled)
+				InfoExceptionDelegate(logger, message, exception);
 		}
 
 		public void InfoFormat(string format, params object[] args)
 		{
-			InfoFormatDelegate(logger, format, args);
+			if (IsInfoEnabled)
+				InfoFormatDelegate(logger, format, args);
 		}
 
 		public void Warn(object message)
 		{
-			WarnDelegate(logger, message);
+			if (IsWarnEnabled)
+				WarnDelegate(logger, message);
 		}
 
 		public void Warn(object message, Exception exception)
 		{
-			WarnExceptionDelegate(logger, message, exception);
+			if (IsWarnEnabled)
+				WarnExceptionDelegate(logger, message, exception);
 		}
 
 		public void WarnFormat(string format, params object[] args)
 		{
-			WarnFormatDelegate(logger, format, args);
+			if (IsWarnEnabled)
+				WarnFormatDelegate(logger, format, args);
 		}
 	}
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate.Test/Logging/Log4NetLoggerTest.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/Logging/Log4NetLoggerTest.cs	2011-05-02 14:08:59 UTC (rev 5793)
+++ trunk/nhibernate/src/NHibernate.Test/Logging/Log4NetLoggerTest.cs	2011-05-02 14:26:59 UTC (rev 5794)
@@ -214,7 +214,7 @@
 				get
 				{
 					isDebugEnabled++;
-					return false;
+					return true;
 				}
 			}
 
@@ -223,7 +223,7 @@
 				get
 				{
 					isInfoEnabled++;
-					return false;
+					return true;
 				}
 			}
 
@@ -232,7 +232,7 @@
 				get
 				{
 					isWarnEnabled++;
-					return false;
+					return true;
 				}
 			}
 
@@ -241,7 +241,7 @@
 				get
 				{
 					isErrorEnabled++;
-					return false;
+					return true;
 				}
 			}
 
@@ -250,7 +250,7 @@
 				get
 				{
 					isFatalEnabled++;
-					return false;
+					return true;
 				}
 			}
 		} 
@@ -299,11 +299,11 @@
 			logMock.errorFormat.Should().Be(1);
 			logMock.fatal.Should().Be(1);
 			logMock.fatalException.Should().Be(1);
-			logMock.isDebugEnabled.Should().Be(1);
-			logMock.isInfoEnabled.Should().Be(1);
-			logMock.isWarnEnabled.Should().Be(1);
-			logMock.isErrorEnabled.Should().Be(1);
-			logMock.isFatalEnabled.Should().Be(1);
+			logMock.isDebugEnabled.Should().Be.GreaterThan(1);
+			logMock.isInfoEnabled.Should().Be.GreaterThan(1);
+			logMock.isWarnEnabled.Should().Be.GreaterThan(1);
+			logMock.isErrorEnabled.Should().Be.GreaterThan(1);
+			logMock.isFatalEnabled.Should().Be.GreaterThan(1);
 		}
 	}
 }
\ No newline at end of file


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5793] trunk/nhibernate/src/NHibernate

[<fab...@us...>]

Revision: 5793
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5793&view=rev
Author:   fabiomaulo
Date:     2011-05-02 14:08:59 +0000 (Mon, 02 May 2011)

Log Message:
-----------
Fix NH-2673, NH-1090, NH-1344

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Cache/QueryKey.cs
    trunk/nhibernate/src/NHibernate/Cache/StandardQueryCache.cs
    trunk/nhibernate/src/NHibernate/Cfg/Loquacious/CacheConfiguration.cs
    trunk/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Loader/QueryLoader.cs
    trunk/nhibernate/src/NHibernate/Hql/Classic/QueryTranslator.cs
    trunk/nhibernate/src/NHibernate/Impl/CriteriaImpl.cs
    trunk/nhibernate/src/NHibernate/Impl/MultiCriteriaImpl.cs
    trunk/nhibernate/src/NHibernate/Impl/MultiQueryImpl.cs
    trunk/nhibernate/src/NHibernate/Loader/Criteria/CriteriaLoader.cs
    trunk/nhibernate/src/NHibernate/Loader/Custom/CustomLoader.cs
    trunk/nhibernate/src/NHibernate/Loader/Loader.cs
    trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj

Added Paths:
-----------
    trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2673/
    trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2673/Blog.cs
    trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2673/CachingWithTrasformerTests.cs

Modified: trunk/nhibernate/src/NHibernate/Cache/QueryKey.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Cache/QueryKey.cs	2011-04-29 22:51:08 UTC (rev 5792)
+++ trunk/nhibernate/src/NHibernate/Cache/QueryKey.cs	2011-05-02 14:08:59 UTC (rev 5793)
@@ -61,6 +61,11 @@
 			hashCode = ComputeHashCode();
 		}
 
+		public bool HasResultTrasformer
+		{
+			get { return customTransformer != null; }
+		}
+
 		public QueryKey SetFirstRows(int[] firstRows)
 		{
 			multiQueriesFirstRows = firstRows;

Modified: trunk/nhibernate/src/NHibernate/Cache/StandardQueryCache.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Cache/StandardQueryCache.cs	2011-04-29 22:51:08 UTC (rev 5792)
+++ trunk/nhibernate/src/NHibernate/Cache/StandardQueryCache.cs	2011-05-02 14:08:59 UTC (rev 5793)
@@ -77,7 +77,7 @@
 			IList cacheable = new List<object>(result.Count + 1) {ts};
 			for (int i = 0; i < result.Count; i++)
 			{
-				if (returnTypes.Length == 1)
+				if (returnTypes.Length == 1 && !key.HasResultTrasformer)
 				{
 					cacheable.Add(returnTypes[0].Disassemble(result[i], session, null));
 				}

Modified: trunk/nhibernate/src/NHibernate/Cfg/Loquacious/CacheConfiguration.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Cfg/Loquacious/CacheConfiguration.cs	2011-04-29 22:51:08 UTC (rev 5792)
+++ trunk/nhibernate/src/NHibernate/Cfg/Loquacious/CacheConfiguration.cs	2011-05-02 14:08:59 UTC (rev 5793)
@@ -35,15 +35,21 @@
 
 		public void Provider<TProvider>() where TProvider : ICacheProvider
 		{
-			cfg.SetProperty(Environment.CacheProvider, typeof (TProvider).AssemblyQualifiedName);
+			UseSecondLevelCache = true;
+			cfg.SetProperty(Environment.CacheProvider, typeof(TProvider).AssemblyQualifiedName);
 		}
 
 		public void QueryCache<TFactory>() where TFactory : IQueryCache
 		{
+			UseSecondLevelCache = true;
 			UseQueryCache = true;
 			cfg.SetProperty(Environment.QueryCacheFactory, typeof(TFactory).AssemblyQualifiedName);
 		}
 
+		private bool UseSecondLevelCache
+		{
+			set { cfg.SetProperty(Environment.UseSecondLevelCache, value.ToString().ToLowerInvariant()); }
+		}
 		#endregion
 	}
 
@@ -66,6 +72,7 @@
 
 		public ICacheConfiguration Through<TProvider>() where TProvider : ICacheProvider
 		{
+			fc.Configuration.SetProperty(Environment.UseSecondLevelCache, "true");
 			fc.Configuration.SetProperty(Environment.CacheProvider, typeof(TProvider).AssemblyQualifiedName);
 			return this;
 		}
@@ -106,6 +113,8 @@
 
 		public ICacheConfiguration Through<TFactory>() where TFactory : IQueryCache
 		{
+			cc.Configuration.SetProperty(Environment.UseSecondLevelCache, "true");
+			cc.Configuration.SetProperty(Environment.UseQueryCache, "true");
 			cc.Configuration.SetProperty(Environment.QueryCacheFactory, typeof(TFactory).AssemblyQualifiedName);
 			return cc;
 		}

Modified: trunk/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Loader/QueryLoader.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Loader/QueryLoader.cs	2011-04-29 22:51:08 UTC (rev 5792)
+++ trunk/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Loader/QueryLoader.cs	2011-05-02 14:08:59 UTC (rev 5793)
@@ -300,7 +300,7 @@
 			return List(session, queryParameters, _queryTranslator.QuerySpaces, _queryReturnTypes);
 		}
 
-		protected override IList GetResultList(IList results, IResultTransformer resultTransformer)
+		public override IList GetResultList(IList results, IResultTransformer resultTransformer)
 		{
 			// meant to handle dynamic instantiation queries...
 			HolderInstantiator holderInstantiator = HolderInstantiator.GetHolderInstantiator(_selectNewTransformer,

Modified: trunk/nhibernate/src/NHibernate/Hql/Classic/QueryTranslator.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Hql/Classic/QueryTranslator.cs	2011-04-29 22:51:08 UTC (rev 5792)
+++ trunk/nhibernate/src/NHibernate/Hql/Classic/QueryTranslator.cs	2011-05-02 14:08:59 UTC (rev 5793)
@@ -1512,7 +1512,7 @@
 			}
 		}
 
-		protected override IList GetResultList(IList results, IResultTransformer resultTransformer)
+		public override IList GetResultList(IList results, IResultTransformer resultTransformer)
 		{
 			HolderInstantiator holderInstantiator =
 				HolderInstantiator.CreateClassicHolderInstantiator(holderConstructor, resultTransformer);

Modified: trunk/nhibernate/src/NHibernate/Impl/CriteriaImpl.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Impl/CriteriaImpl.cs	2011-04-29 22:51:08 UTC (rev 5792)
+++ trunk/nhibernate/src/NHibernate/Impl/CriteriaImpl.cs	2011-05-02 14:08:59 UTC (rev 5793)
@@ -26,7 +26,7 @@
 		private int timeout = RowSelection.NoValue;
 		private int fetchSize = RowSelection.NoValue;
 		private ISessionImplementor session;
-		private IResultTransformer resultTransformer = CriteriaSpecification.RootEntity;
+		private IResultTransformer resultTransformer;
 		private bool cacheable;
 		private string cacheRegion;
 		private CacheMode? cacheMode;

Modified: trunk/nhibernate/src/NHibernate/Impl/MultiCriteriaImpl.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Impl/MultiCriteriaImpl.cs	2011-04-29 22:51:08 UTC (rev 5792)
+++ trunk/nhibernate/src/NHibernate/Impl/MultiCriteriaImpl.cs	2011-05-02 14:08:59 UTC (rev 5793)
@@ -14,6 +14,7 @@
 using NHibernate.SqlCommand;
 using NHibernate.Transform;
 using NHibernate.Type;
+using NHibernate.Util;
 
 namespace NHibernate.Impl
 {
@@ -91,7 +92,6 @@
 			}
 		}
 
-
 		private IList ListUsingQueryCache()
 		{
 			IQueryCache queryCache = session.Factory.GetQueryCache(cacheRegion);
@@ -141,21 +141,28 @@
 
 		protected virtual IList GetResultList(IList results)
 		{
-			if (resultTransformer != null)
+			for (int i = 0; i < loaders.Count; i++)
 			{
-				for (int i = 0; i < results.Count; i++)
+				CriteriaLoader loader = loaders[i];
+				results[i] = loader.GetResultList((IList)results[i], parameters[i].ResultTransformer);
+				IList tmpResults;
+				if (resultCollectionGenericType[i] == typeof (object))
 				{
-					results[i] = resultTransformer.TransformList((IList)results[i]);
+					tmpResults = new ArrayList();
 				}
+				else
+				{
+					tmpResults = (IList) Activator.CreateInstance(typeof (List<>).MakeGenericType(resultCollectionGenericType[i]));
+				}
+				ArrayHelper.AddAll(tmpResults, (IList)results[i]);
+
+				results[i] = tmpResults;
 			}
-			else
+			if (resultTransformer != null)
 			{
 				for (int i = 0; i < results.Count; i++)
 				{
-					CriteriaImpl critImp = criteriaQueries[i] as CriteriaImpl;
-					if (critImp == null || critImp.ResultTransformer == null)
-						continue;
-					results[i] = critImp.ResultTransformer.TransformList((IList)results[i]);
+					results[i] = resultTransformer.TransformList((IList)results[i]);
 				}
 			}
 			return results;
@@ -205,15 +212,7 @@
 						hydratedObjects[i] = entitySpan == 0 ? null : new ArrayList(entitySpan);
 						EntityKey[] keys = new EntityKey[entitySpan];
 						QueryParameters queryParameters = parameters[i];
-						IList tmpResults;
-						if (resultCollectionGenericType[i] == typeof(object))
-						{
-							tmpResults = new ArrayList();
-						}
-						else
-						{
-							tmpResults = (IList)Activator.CreateInstance(typeof(List<>).MakeGenericType(resultCollectionGenericType[i]));
-						}
+						IList tmpResults = new ArrayList();
 
 						RowSelection selection = parameters[i].RowSelection;
 						createSubselects[i] = loader.IsSubselectLoadingEnabled;
@@ -238,6 +237,7 @@
 							}
 							tmpResults.Add(o);
 						}
+
 						results.Add(tmpResults);
 						reader.NextResult();
 					}

Modified: trunk/nhibernate/src/NHibernate/Impl/MultiQueryImpl.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Impl/MultiQueryImpl.cs	2011-04-29 22:51:08 UTC (rev 5792)
+++ trunk/nhibernate/src/NHibernate/Impl/MultiQueryImpl.cs	2011-05-02 14:08:59 UTC (rev 5793)
@@ -453,7 +453,8 @@
 			for (int i = 0; i < len; ++i)
 			{
 				// First use the transformer of each query transformig each row and then the list
-				results[i] = GetTransformedResults((IList)results[i], GetQueryHolderInstantiator(i));
+				// DONE: The behavior when the query has a 'new' istead a trasformer is delegated to the Loader
+				results[i] = translators[i].Loader.GetResultList((IList)results[i], Parameters[i].ResultTransformer);
 				// then use the MultiQueryTransformer (if it has some sense...) using, as source, the transformed result.
 				results[i] = GetTransformedResults((IList)results[i], multiqueryHolderInstatiator);
 			}
@@ -475,15 +476,6 @@
 			return holderInstantiator.ResultTransformer.TransformList(source);
 		}
 
-		private HolderInstantiator GetQueryHolderInstantiator(int queryPosition)
-		{
-			// TODO : we need a test to check the behavior when the query has a 'new' istead a trasformer
-			// we should take the HolderInstantiator directly from QueryTranslator... taking care with Parameters.
-			return Parameters[queryPosition].ResultTransformer != null ?
-				new HolderInstantiator(Parameters[queryPosition].ResultTransformer, translators[queryPosition].ReturnAliases)
-				: HolderInstantiator.NoopInstantiator;
-		}
-
 		private HolderInstantiator GetMultiQueryHolderInstatiator()
 		{
 			return HasMultiQueryResultTrasformer() ? new HolderInstantiator(resultTransformer, null) : HolderInstantiator.NoopInstantiator;

Modified: trunk/nhibernate/src/NHibernate/Loader/Criteria/CriteriaLoader.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Loader/Criteria/CriteriaLoader.cs	2011-04-29 22:51:08 UTC (rev 5792)
+++ trunk/nhibernate/src/NHibernate/Loader/Criteria/CriteriaLoader.cs	2011-05-02 14:08:59 UTC (rev 5793)
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Data;
 using Iesi.Collections.Generic;
+using NHibernate.Criterion;
 using NHibernate.Engine;
 using NHibernate.Impl;
 using NHibernate.Persister.Entity;
@@ -78,7 +79,6 @@
 		                                               ISessionImplementor session)
 		{
 			object[] result;
-			string[] aliases;
 
 			if (translator.HasProjection)
 			{
@@ -101,14 +101,17 @@
 					}
 					position += numColumns;
 				}
-				aliases = translator.ProjectedAliases;
 			}
 			else
 			{
 				result = row;
-				aliases = userAliases;
 			}
-			return translator.RootCriteria.ResultTransformer.TransformTuple(result, aliases);
+
+			if (resultTransformer == null && result.Length == 1)
+			{
+				return result[0];
+			}
+			return result;
 		}
 
 		protected override SqlString ApplyLocks(SqlString sqlSelectString, IDictionary<string, LockMode> lockModes,
@@ -161,9 +164,20 @@
 			return lockModesArray;
 		}
 
-		protected override IList GetResultList(IList results, IResultTransformer resultTransformer)
+		public override IList GetResultList(IList results, IResultTransformer resultTransformer)
 		{
-			return translator.RootCriteria.ResultTransformer.TransformList(results);
+			var transformer = resultTransformer ?? CriteriaSpecification.RootEntity;
+			for (int i = 0; i < results.Count; i++)
+			{
+				var row = results[i] as object[];
+				if(row == null)
+				{
+					row = new object[] { results[i] };
+				}
+				object result = transformer.TransformTuple(row, translator.HasProjection ? translator.ProjectedAliases : userAliases);
+				results[i] = result;
+			}
+			return transformer.TransformList(results);
 		}
 	}
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate/Loader/Custom/CustomLoader.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Loader/Custom/CustomLoader.cs	2011-04-29 22:51:08 UTC (rev 5792)
+++ trunk/nhibernate/src/NHibernate/Loader/Custom/CustomLoader.cs	2011-05-02 14:08:59 UTC (rev 5793)
@@ -280,7 +280,7 @@
 			return rowProcessor.BuildResultRow(row, rs, resultTransformer != null, session);
 		}
 
-		protected override IList GetResultList(IList results, IResultTransformer resultTransformer)
+		public override IList GetResultList(IList results, IResultTransformer resultTransformer)
 		{
 			// meant to handle dynamic instantiation queries...(Copy from QueryLoader)
 			HolderInstantiator holderInstantiator =

Modified: trunk/nhibernate/src/NHibernate/Loader/Loader.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Loader/Loader.cs	2011-04-29 22:51:08 UTC (rev 5792)
+++ trunk/nhibernate/src/NHibernate/Loader/Loader.cs	2011-05-02 14:08:59 UTC (rev 5793)
@@ -628,7 +628,7 @@
 				collectionPersister);
 		}
 
-		protected virtual IList GetResultList(IList results, IResultTransformer resultTransformer)
+		public virtual IList GetResultList(IList results, IResultTransformer resultTransformer)
 		{
 			return results;
 		}

Added: trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2673/Blog.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2673/Blog.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2673/Blog.cs	2011-05-02 14:08:59 UTC (rev 5793)
@@ -0,0 +1,34 @@
+using Iesi.Collections.Generic;
+
+namespace NHibernate.Test.NHSpecificTest.NH2673
+{
+	public class Blog
+	{
+		public Blog()
+		{
+			Posts = new HashedSet<Post>();
+			Comments = new HashedSet<Comment>();
+		}
+
+		public virtual int Id { get; set; }
+		public virtual string Author { get; set; }
+		public virtual string Name { get; set; }
+		public virtual ISet<Post> Posts { get; set; }
+		public virtual ISet<Comment> Comments { get; set; }
+	}
+
+	public class Post
+	{
+		public virtual int Id { get; protected set; }
+		public virtual string Title { get; set; }
+		public virtual string Body { get; set; }
+	}
+
+
+	public class Comment
+	{
+		public virtual int Id { get; protected set; }
+		public virtual string Title { get; set; }
+		public virtual string Body { get; set; }
+	}
+}
\ No newline at end of file

Added: trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2673/CachingWithTrasformerTests.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2673/CachingWithTrasformerTests.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/NHSpecificTest/NH2673/CachingWithTrasformerTests.cs	2011-05-02 14:08:59 UTC (rev 5793)
@@ -0,0 +1,157 @@
+using System;
+using System.Collections;
+using NHibernate.Cache;
+using NHibernate.Cfg;
+using NHibernate.Cfg.MappingSchema;
+using NHibernate.Mapping.ByCode;
+using NHibernate.Transform;
+using NUnit.Framework;
+using SharpTestsEx;
+
+namespace NHibernate.Test.NHSpecificTest.NH2673
+{
+	public class CachingWithTrasformerTests: TestCaseMappingByCode
+	{
+		protected override HbmMapping GetMappings()
+		{
+			var mapper = new ConventionModelMapper();
+			mapper.BeforeMapClass += (inspector, type, map) => map.Id(x => x.Generator(Generators.HighLow));
+			mapper.BeforeMapClass += (inspector, type, map) => map.Cache(x => x.Usage(CacheUsage.ReadWrite));
+			mapper.BeforeMapSet += (inspector, property, map) =>
+			                       {
+			                       	map.Cascade(Mapping.ByCode.Cascade.All);
+			                       	map.Cache(x => x.Usage(CacheUsage.ReadWrite));
+			                       };
+			var mapping = mapper.CompileMappingFor(new[] { typeof(Blog), typeof(Post), typeof(Comment) });
+			return mapping;
+		}
+
+		protected override void Configure(Cfg.Configuration configuration)
+		{
+			configuration.Cache(x =>
+			                    {
+			                    	x.Provider<HashtableCacheProvider>();
+			                    	x.UseQueryCache = true;
+			                    });
+		}
+
+		private class Scenario: IDisposable
+		{
+			private readonly ISessionFactory factory;
+
+			public Scenario(ISessionFactory factory)
+			{
+				this.factory = factory;
+				using (var session= factory.OpenSession())
+				using (var tx = session.BeginTransaction())
+				{
+					var blog = new Blog { Author = "Gabriel", Name = "Keep on running" };
+					blog.Posts.Add(new Post { Title = "First post", Body = "Some text" });
+					blog.Posts.Add(new Post { Title = "Second post", Body = "Some other text" });
+					blog.Posts.Add(new Post { Title = "Third post", Body = "Third post text" });
+
+
+					blog.Comments.Add(new Comment { Title = "First comment", Body = "Some text" });
+					blog.Comments.Add(new Comment { Title = "Second comment", Body = "Some other text" });
+					session.Save(blog);
+					tx.Commit();
+				}
+			}
+
+			public void Dispose()
+			{
+				using (var session = factory.OpenSession())
+				using (var tx = session.BeginTransaction())
+				{
+					session.CreateQuery("delete from Comment").ExecuteUpdate();
+					session.CreateQuery("delete from Post").ExecuteUpdate();
+					session.CreateQuery("delete from Blog").ExecuteUpdate();
+					tx.Commit();
+				}
+			}
+		}
+
+		[Test]
+		public void WhenQueryThenNotThrows()
+		{
+			using (new Scenario(Sfi))
+			{
+				using (var session = OpenSession())
+				using (var tx = session.BeginTransaction())
+				{
+					var query = session.CreateQuery("from Blog b where b.Author = : author")
+						.SetString("author", "Gabriel")
+						.SetCacheable(true)
+						.SetResultTransformer(new DistinctRootEntityResultTransformer());
+					query.Executing(q=> q.List<Blog>()).NotThrows();
+					tx.Commit();
+				}
+			}
+		}
+
+		[Test]
+		public void WhenCriteriaThenNotThrows()
+		{
+			using (new Scenario(Sfi))
+			{
+				using (var session = OpenSession())
+				using (var tx = session.BeginTransaction())
+				{
+					var query = session.QueryOver<Blog>().Where(x => x.Author == "Gabriel")
+						.TransformUsing(new DistinctRootEntityResultTransformer())
+						.Cacheable();
+					query.Executing(q => q.List<Blog>()).NotThrows();
+					tx.Commit();
+				}
+			}
+		}
+
+		private class BlogAuthorDto
+		{
+			public string BlogName { get; set; }
+			public string AuthorName { get; set; }
+		}
+
+		private class BlogAuthorTrasformer : IResultTransformer
+		{
+			public object TransformTuple(object[] tuple, string[] aliases)
+			{
+				return new BlogAuthorDto { BlogName = tuple[0].ToString(), AuthorName = tuple[1].ToString() };
+			}
+
+			public IList TransformList(IList collection)
+			{
+				return collection;
+			}
+		}
+
+		[Test]
+		public void WhenCriteriaProjectionThenNotThrows()
+		{
+			// during the fix of NH-2673 was faund another bug related to cacheability of criteria with projection + trasformer 
+			// then found reported as NH-1090
+			var transformer = new BlogAuthorTrasformer();
+			using (new Scenario(Sfi))
+			{
+				using (var session = OpenSession())
+				using (var tx = session.BeginTransaction())
+				{
+					var query = session.QueryOver<Blog>().Select(x=> x.Author, x=> x.Name).Where(x => x.Author == "Gabriel")
+						.TransformUsing(transformer)
+						.Cacheable();
+					query.List<BlogAuthorDto>();
+					tx.Commit();
+				}
+				using (var session = OpenSession())
+				using (var tx = session.BeginTransaction())
+				{
+					var query = session.QueryOver<Blog>().Select(x => x.Author, x => x.Name).Where(x => x.Author == "Gabriel")
+						.TransformUsing(transformer)
+						.Cacheable();
+					query.Executing(q => q.List<BlogAuthorDto>()).NotThrows();
+					tx.Commit();
+				}
+			}
+		}
+	}
+}
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-04-29 22:51:08 UTC (rev 5792)
+++ trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-05-02 14:08:59 UTC (rev 5793)
@@ -810,6 +810,8 @@
     <Compile Include="NHSpecificTest\NH2632\Fixture.cs" />
     <Compile Include="NHSpecificTest\NH2660And2661\DomainClass.cs" />
     <Compile Include="NHSpecificTest\NH2660And2661\Test.cs" />
+    <Compile Include="NHSpecificTest\NH2673\Blog.cs" />
+    <Compile Include="NHSpecificTest\NH2673\CachingWithTrasformerTests.cs" />
     <Compile Include="NHSpecificTest\Properties\CompositePropertyRefTest.cs" />
     <Compile Include="NHSpecificTest\Properties\DynamicEntityTest.cs" />
     <Compile Include="NHSpecificTest\Properties\Model.cs" />


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5792] trunk/nhibernate/src/NHibernate

[<fab...@us...>]

Revision: 5792
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5792&view=rev
Author:   fabiomaulo
Date:     2011-04-29 22:51:08 +0000 (Fri, 29 Apr 2011)

Log Message:
-----------
not visible checking declared types

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/ClassCustomizer.cs
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/PropertyContainerCustomizer.cs
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/SimpleModelInspector.cs
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/AllPropertiesRegistrationTests.cs
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/MappingOfPrivateMembersOnRootEntity.cs

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/ClassCustomizer.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/ClassCustomizer.cs	2011-04-29 21:31:40 UTC (rev 5791)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/ClassCustomizer.cs	2011-04-29 22:51:08 UTC (rev 5792)
@@ -18,6 +18,9 @@
 				throw new ArgumentNullException("explicitDeclarationsHolder");
 			}
 			explicitDeclarationsHolder.AddAsRootEntity(typeof (TEntity));
+
+			// Add an empty customizer as a way to register the class as explicity declared
+			CustomizersHolder.AddCustomizer(typeof(TEntity), (IClassMapper m) => { });
 		}
 
 		private Dictionary<string, IJoinMapper<TEntity>> JoinCustomizers

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/PropertyContainerCustomizer.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/PropertyContainerCustomizer.cs	2011-04-29 21:31:40 UTC (rev 5791)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/PropertyContainerCustomizer.cs	2011-04-29 22:51:08 UTC (rev 5792)
@@ -55,7 +55,7 @@
 		{
 			// even seems repetitive, before unify this registration with the registration using Expression take in account that reflection operations
 			// done unsing expressions are faster than those done with pure reflection.
-			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo member = GetPropertyOrFieldMatchingNameOrThrow(notVidiblePropertyOrFieldName);
 			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
 			RegistePropertyMapping(mapping, member, memberOf);
 		}
@@ -346,7 +346,13 @@
 
 		public void Set<TElement>(string notVidiblePropertyOrFieldName, Action<ISetPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping)
 		{
-			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo member = GetPropertyOrFieldMatchingNameOrThrow(notVidiblePropertyOrFieldName);
+			var collectionElementType = member.GetPropertyOrFieldType().DetermineCollectionElementType();
+			if(!typeof(TElement).Equals(collectionElementType))
+			{
+				throw new MappingException(string.Format("Wrong collection element type. For the property/field '{0}' of {1} was expected a collection of {2} but was {3}",
+				                                         notVidiblePropertyOrFieldName, typeof (TEntity).FullName, typeof (TElement).Name, collectionElementType.Name));
+			}
 			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
 			RegisterSetMapping<TElement>(collectionMapping, mapping, member, memberOf);
 		}
@@ -358,7 +364,13 @@
 
 		public void Bag<TElement>(string notVidiblePropertyOrFieldName, Action<IBagPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping)
 		{
-			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo member = GetPropertyOrFieldMatchingNameOrThrow(notVidiblePropertyOrFieldName);
+			var collectionElementType = member.GetPropertyOrFieldType().DetermineCollectionElementType();
+			if (!typeof(TElement).Equals(collectionElementType))
+			{
+				throw new MappingException(string.Format("Wrong collection element type. For the property/field '{0}' of {1} was expected a collection of {2} but was {3}",
+																								 notVidiblePropertyOrFieldName, typeof(TEntity).FullName, typeof(TElement).Name, collectionElementType.Name));
+			}
 			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
 			RegisterBagMapping<TElement>(collectionMapping, mapping, member, memberOf);
 		}
@@ -370,7 +382,13 @@
 
 		public void List<TElement>(string notVidiblePropertyOrFieldName, Action<IListPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping)
 		{
-			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo member = GetPropertyOrFieldMatchingNameOrThrow(notVidiblePropertyOrFieldName);
+			var collectionElementType = member.GetPropertyOrFieldType().DetermineCollectionElementType();
+			if (!typeof(TElement).Equals(collectionElementType))
+			{
+				throw new MappingException(string.Format("Wrong collection element type. For the property/field '{0}' of {1} was expected a collection of {2} but was {3}",
+																								 notVidiblePropertyOrFieldName, typeof(TEntity).FullName, typeof(TElement).Name, collectionElementType.Name));
+			}
 			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
 			RegisterListMapping<TElement>(collectionMapping, mapping, member, memberOf);
 		}
@@ -382,7 +400,15 @@
 
 		public void Map<TKey, TElement>(string notVidiblePropertyOrFieldName, Action<IMapPropertiesMapper<TEntity, TKey, TElement>> collectionMapping, Action<IMapKeyRelation<TKey>> keyMapping, Action<ICollectionElementRelation<TElement>> mapping)
 		{
-			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo member = GetPropertyOrFieldMatchingNameOrThrow(notVidiblePropertyOrFieldName);
+			var propertyOrFieldType = member.GetPropertyOrFieldType();
+			var keyType = propertyOrFieldType.DetermineDictionaryKeyType();
+			var collectionElementType = propertyOrFieldType.DetermineDictionaryValueType();
+			if (!typeof(TElement).Equals(collectionElementType) || !typeof(TKey).Equals(keyType))
+			{
+				throw new MappingException(string.Format("Wrong collection element type. For the property/field '{0}' of {1} was expected a dictionary of {2}/{3} but was {4}/{5}",
+																								 notVidiblePropertyOrFieldName, typeof(TEntity).FullName, typeof(TKey).Name, keyType.Name ,typeof(TElement).Name, collectionElementType.Name));
+			}
 			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
 			RegisterMapMapping<TKey, TElement>(collectionMapping, keyMapping, mapping, member, memberOf);
 		}
@@ -399,7 +425,13 @@
 
 		public void IdBag<TElement>(string notVidiblePropertyOrFieldName, Action<IIdBagPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping)
 		{
-			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo member = GetPropertyOrFieldMatchingNameOrThrow(notVidiblePropertyOrFieldName);
+			var collectionElementType = member.GetPropertyOrFieldType().DetermineCollectionElementType();
+			if (!typeof(TElement).Equals(collectionElementType))
+			{
+				throw new MappingException(string.Format("Wrong collection element type. For the property/field '{0}' of {1} was expected a collection of {2} but was {3}",
+																								 notVidiblePropertyOrFieldName, typeof(TEntity).FullName, typeof(TElement).Name, collectionElementType.Name));
+			}
 			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
 			RegisterIdBagMapping<TElement>(collectionMapping, mapping, member, memberOf);
 		}
@@ -411,14 +443,26 @@
 
 		public void ManyToOne<TProperty>(string notVidiblePropertyOrFieldName, Action<IManyToOneMapper> mapping) where TProperty : class
 		{
-			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo member = GetPropertyOrFieldMatchingNameOrThrow(notVidiblePropertyOrFieldName);
+			var propertyOrFieldType = member.GetPropertyOrFieldType();
+			if (!typeof(TProperty).Equals(propertyOrFieldType))
+			{
+				throw new MappingException(string.Format("Wrong relation type. For the property/field '{0}' of {1} was expected a many-to-one with {2} but was {3}",
+																								 notVidiblePropertyOrFieldName, typeof(TEntity).FullName, typeof(TProperty).Name, propertyOrFieldType.Name));
+			}
 			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
 			RegisterManyToOneMapping<TProperty>(mapping, member, memberOf);
 		}
 
 		public void Component<TComponent>(string notVidiblePropertyOrFieldName, Action<IComponentMapper<TComponent>> mapping) where TComponent : class
 		{
-			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo member = GetPropertyOrFieldMatchingNameOrThrow(notVidiblePropertyOrFieldName);
+			var propertyOrFieldType = member.GetPropertyOrFieldType();
+			if (!typeof(TComponent).Equals(propertyOrFieldType))
+			{
+				throw new MappingException(string.Format("Wrong relation type. For the property/field '{0}' of {1} was expected a component of {2} but was {3}",
+																								 notVidiblePropertyOrFieldName, typeof(TEntity).FullName, typeof(TComponent).Name, propertyOrFieldType.Name));
+			}
 			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
 			RegisterComponentMapping<TComponent>(mapping, member, memberOf);
 		}
@@ -430,23 +474,45 @@
 
 		public void Component<TComponent>(string notVidiblePropertyOrFieldName, TComponent dynamicComponentTemplate, Action<IDynamicComponentMapper<TComponent>> mapping) where TComponent : class
 		{
-			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo member = GetPropertyOrFieldMatchingNameOrThrow(notVidiblePropertyOrFieldName);
 			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
 			RegisterDynamicComponentMapping<TComponent>(mapping, member, memberOf);
 		}
 
 		public void Any<TProperty>(string notVidiblePropertyOrFieldName, System.Type idTypeOfMetaType, Action<IAnyMapper> mapping) where TProperty : class
 		{
-			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo member = GetPropertyOrFieldMatchingNameOrThrow(notVidiblePropertyOrFieldName);
+			var propertyOrFieldType = member.GetPropertyOrFieldType();
+			if (!typeof(TProperty).Equals(propertyOrFieldType))
+			{
+				throw new MappingException(string.Format("Wrong relation type. For the property/field '{0}' of {1} was expected a heterogeneous (any) of type {2} but was {3}",
+																								 notVidiblePropertyOrFieldName, typeof(TEntity).FullName, typeof(TProperty).Name, propertyOrFieldType.Name));
+			}
 			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
 			RegisterAnyMapping<TProperty>(mapping, idTypeOfMetaType, member, memberOf);
 		}
 
 		public void OneToOne<TProperty>(string notVidiblePropertyOrFieldName, Action<IOneToOneMapper> mapping) where TProperty : class
 		{
-			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo member = GetPropertyOrFieldMatchingNameOrThrow(notVidiblePropertyOrFieldName);
+			var propertyOrFieldType = member.GetPropertyOrFieldType();
+			if (!typeof(TProperty).Equals(propertyOrFieldType))
+			{
+				throw new MappingException(string.Format("Wrong relation type. For the property/field '{0}' of {1} was expected a one-to-one with {2} but was {3}",
+																								 notVidiblePropertyOrFieldName, typeof(TEntity).FullName, typeof(TProperty).Name, propertyOrFieldType.Name));
+			}
 			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
 			RegisterOneToOneMapping<TProperty>(mapping, member, memberOf);
 		}
+
+		public static MemberInfo GetPropertyOrFieldMatchingNameOrThrow(string memberName)
+		{
+			var result = typeof(TEntity).GetPropertyOrFieldMatchingName(memberName);
+			if (result == null)
+			{
+				throw new MappingException(string.Format("Member not found. The member '{0}' does not exists in type {1}", memberName, typeof(TEntity).FullName));
+			}
+			return result;
+		}
 	}
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/SimpleModelInspector.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/SimpleModelInspector.cs	2011-04-29 21:31:40 UTC (rev 5791)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/SimpleModelInspector.cs	2011-04-29 22:51:08 UTC (rev 5792)
@@ -214,10 +214,10 @@
 				BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
 
 			var modelInspector = (IModelInspector) this;
-			return !subject.IsEnum && !subject.Namespace.StartsWith("System") /* hack */&& !modelInspector.IsEntity(subject)
-			       &&
-			       !subject.GetProperties(flattenHierarchyMembers).Cast<MemberInfo>().Concat(
-			       	subject.GetFields(flattenHierarchyMembers)).Any(m => modelInspector.IsPersistentId(m));
+			return !subject.IsEnum && (subject.Namespace == null || !subject.Namespace.StartsWith("System")) /* hack */
+							&& !modelInspector.IsEntity(subject)
+							&& !subject.GetProperties(flattenHierarchyMembers).Cast<MemberInfo>().Concat(
+			       		subject.GetFields(flattenHierarchyMembers)).Any(m => modelInspector.IsPersistentId(m));
 		}
 
 		protected bool MatchEntity(System.Type subject)

Modified: trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/AllPropertiesRegistrationTests.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/AllPropertiesRegistrationTests.cs	2011-04-29 21:31:40 UTC (rev 5791)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/AllPropertiesRegistrationTests.cs	2011-04-29 22:51:08 UTC (rev 5792)
@@ -154,8 +154,9 @@
 			// ignoring MyClass and using Inherited, as root-class, I will try to map all properties using the base class.
 			// NH have to recognize the case and map those properties in the inherited.
 			var inspector = new SimpleModelInspector();
+			inspector.IsEntity((type, declared) => type == typeof(Inherited));
 			inspector.IsRootEntity((type, declared) => type == typeof(Inherited));
-			var mapper = new ModelMapper();
+			var mapper = new ModelMapper(inspector);
 			mapper.Class<MyClass>(mc =>
 			                      {
 			                      	mc.Id(x => x.Id);
@@ -225,8 +226,9 @@
 			// ignoring MyClass and using Inherited, as root-class, I will try to map all properties using the base class.
 			// NH have to recognize the case and map those properties in the inherited.
 			var inspector = new SimpleModelInspector();
-			inspector.IsRootEntity((type, declared) => type == typeof (Inherited));
-			var mapper = new ModelMapper();
+			inspector.IsEntity((type, declared) => type == typeof(Inherited));
+			inspector.IsRootEntity((type, declared) => type == typeof(Inherited));
+			var mapper = new ModelMapper(inspector);
 			mapper.Class<MyClass>(mc =>
 			                      {
 			                      	mc.Id(x => x.Id);
@@ -256,5 +258,126 @@
 			                                                                   "DynamicCompo");
 			hbmClass.Properties.Select(p => p.Access).All(x => x.Satisfy(access => access.Contains("field.")));
 		}
+
+		[Test]
+		public void WhenMapBagWithWrongElementTypeThenThrows()
+		{
+			var mapper = new ModelMapper();
+			Executing.This(() =>
+										 mapper.Class<MyClass>(mc =>
+										 {
+											 mc.Id(x => x.Id);
+											 mc.Bag<int>("Bag", y => y.Access(Accessor.Field));
+										 })).Should().Throw<MappingException>();
+		}
+
+		[Test]
+		public void WhenMapIdBagWithWrongElementTypeThenThrows()
+		{
+			var mapper = new ModelMapper();
+			Executing.This(() =>
+										 mapper.Class<MyClass>(mc =>
+										 {
+											 mc.Id(x => x.Id);
+											 mc.IdBag<int>("IdBag", y => y.Access(Accessor.Field));
+										 })).Should().Throw<MappingException>();
+		}
+
+		[Test]
+		public void WhenMapSetWithWrongElementTypeThenThrows()
+		{
+			var mapper = new ModelMapper();
+			Executing.This(() =>
+										 mapper.Class<MyClass>(mc =>
+										 {
+											 mc.Id(x => x.Id);
+											 mc.Set<int>("Set", y => y.Access(Accessor.Field));
+										 })).Should().Throw<MappingException>();
+		}
+
+		[Test]
+		public void WhenMapListWithWrongElementTypeThenThrows()
+		{
+			var mapper = new ModelMapper();
+			Executing.This(() =>
+										 mapper.Class<MyClass>(mc =>
+										 {
+											 mc.Id(x => x.Id);
+											 mc.Set<int>("Set", y => y.Access(Accessor.Field));
+										 })).Should().Throw<MappingException>();
+		}
+
+		[Test]
+		public void WhenMapDictionaryWithWrongKeyTypeThenThrows()
+		{
+			var mapper = new ModelMapper();
+			Executing.This(() =>
+										 mapper.Class<MyClass>(mc =>
+										 {
+											 mc.Id(x => x.Id);
+											 mc.Map<string, string>("Map", y => y.Access(Accessor.Field));
+										 })).Should().Throw<MappingException>();
+		}
+
+		[Test]
+		public void WhenMapDictionaryWithWrongValueTypeThenThrows()
+		{
+			var mapper = new ModelMapper();
+			Executing.This(() =>
+										 mapper.Class<MyClass>(mc =>
+										 {
+											 mc.Id(x => x.Id);
+											 mc.Map<int, int>("Map", y => y.Access(Accessor.Field));
+										 })).Should().Throw<MappingException>();
+		}
+
+		[Test]
+		public void WhenMapComponentWithWrongElementTypeThenThrows()
+		{
+			var mapper = new ModelMapper();
+			Executing.This(() =>
+										 mapper.Class<MyClass>(mc =>
+										 {
+											 mc.Id(x => x.Id);
+											 mc.Component<object>("Compo", y => y.Access(Accessor.Field));
+										 })).Should().Throw<MappingException>();
+		}
+
+
+		[Test]
+		public void WhenMapOneToOneWithWrongTypeThenThrows()
+		{
+			var mapper = new ModelMapper();
+			Executing.This(() =>
+										 mapper.Class<MyClass>(mc =>
+										 {
+											 mc.Id(x => x.Id);
+											 mc.OneToOne<object>("OneToOne", y => y.Access(Accessor.Field));
+										 })).Should().Throw<MappingException>();
+		}
+
+		[Test]
+		public void WhenMapManyToOneWithWrongTypeThenThrows()
+		{
+			var mapper = new ModelMapper();
+			Executing.This(() =>
+										 mapper.Class<MyClass>(mc =>
+										 {
+											 mc.Id(x => x.Id);
+											 mc.ManyToOne<object>("ManyToOne", y => y.Access(Accessor.Field));
+										 })).Should().Throw<MappingException>();
+		}
+
+		[Test]
+		public void WhenMapAnyWithWrongTypeThenThrows()
+		{
+			var mapper = new ModelMapper();
+			Executing.This(() =>
+										 mapper.Class<MyClass>(mc =>
+										 {
+											 mc.Id(x => x.Id);
+											 mc.Any<Related>("Any", typeof(int),y => y.Access(Accessor.Field));
+										 })).Should().Throw<MappingException>();
+		}
 	}
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/MappingOfPrivateMembersOnRootEntity.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/MappingOfPrivateMembersOnRootEntity.cs	2011-04-29 21:31:40 UTC (rev 5791)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/MappingOfPrivateMembersOnRootEntity.cs	2011-04-29 22:51:08 UTC (rev 5792)
@@ -48,5 +48,16 @@
 			hbmProperty.access.Should().Be("field");
 			hbmProperty.length.Should().Be("150");
 		}
+
+		[Test]
+		public void WhenPrivateMemberDoesNotExistsThenThrow()
+		{
+			var mapper = new ModelMapper();
+			Executing.This(() =>
+			mapper.Class<MyClass>(ca =>
+			{
+				ca.Property("pizza", map => map.Length(150));
+			})).Should().Throw<MappingException>();
+		}
 	}
 }
\ No newline at end of file


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5791] trunk/nhibernate/src/NHibernate

[<fab...@us...>]

Revision: 5791
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5791&view=rev
Author:   fabiomaulo
Date:     2011-04-29 21:31:40 +0000 (Fri, 29 Apr 2011)

Log Message:
-----------
Class Customizers with mapping of not visible id/version

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/IClassMapper.cs
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/ClassCustomizer.cs
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/MappingOfPrivateMembersOnRootEntity.cs

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/IClassMapper.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/IClassMapper.cs	2011-04-29 21:16:22 UTC (rev 5790)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/IClassMapper.cs	2011-04-29 21:31:40 UTC (rev 5791)
@@ -40,10 +40,12 @@
 	{
 		void Id<TProperty>(Expression<Func<TEntity, TProperty>> idProperty);
 		void Id<TProperty>(Expression<Func<TEntity, TProperty>> idProperty, Action<IIdMapper> idMapper);
-		void Id(FieldInfo idProperty, Action<IIdMapper> idMapper);
+		void Id(string notVidiblePropertyOrFieldName, Action<IIdMapper> idMapper);
 
 		void ComponentAsId<TComponent>(Expression<Func<TEntity, TComponent>> idProperty) where TComponent : class;
 		void ComponentAsId<TComponent>(Expression<Func<TEntity, TComponent>> idProperty, Action<IComponentAsIdMapper<TComponent>> idMapper) where TComponent : class;
+		void ComponentAsId<TComponent>(string notVidiblePropertyOrFieldName) where TComponent : class;
+		void ComponentAsId<TComponent>(string notVidiblePropertyOrFieldName, Action<IComponentAsIdMapper<TComponent>> idMapper) where TComponent : class;
 
 		void ComposedId(Action<IComposedIdMapper<TEntity>> idPropertiesMapping);
 
@@ -54,6 +56,7 @@
 		void Schema(string schemaName);
 		void Mutable(bool isMutable);
 		void Version<TProperty>(Expression<Func<TEntity, TProperty>> versionProperty, Action<IVersionMapper> versionMapping);
+		void Version(string notVidiblePropertyOrFieldName, Action<IVersionMapper> versionMapping);
 		void NaturalId(Action<IBasePlainPropertyContainerMapper<TEntity>> naturalIdPropertiesMapping, Action<INaturalIdAttributesMapper> naturalIdMapping);
 		void NaturalId(Action<IBasePlainPropertyContainerMapper<TEntity>> naturalIdPropertiesMapping);
 		void Cache(Action<ICacheMapper> cacheMapping);

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/ClassCustomizer.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/ClassCustomizer.cs	2011-04-29 21:16:22 UTC (rev 5790)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/ClassCustomizer.cs	2011-04-29 21:31:40 UTC (rev 5791)
@@ -43,13 +43,15 @@
 			CustomizersHolder.AddCustomizer(typeof (TEntity), m => m.Id(member, idMapper));
 		}
 
-		public void Id(FieldInfo idProperty, Action<IIdMapper> idMapper)
+		public void Id(string notVidiblePropertyOrFieldName, Action<IIdMapper> idMapper)
 		{
-			if (idProperty != null)
+			MemberInfo member = null;
+			if (notVidiblePropertyOrFieldName != null)
 			{
-				ExplicitDeclarationsHolder.AddAsPoid(idProperty);
+				member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+				ExplicitDeclarationsHolder.AddAsPoid(member);
 			}
-			CustomizersHolder.AddCustomizer(typeof(TEntity), m => m.Id(idProperty, idMapper));
+			CustomizersHolder.AddCustomizer(typeof(TEntity), m => m.Id(member, idMapper));
 		}
 
 		public void ComponentAsId<TComponent>(Expression<Func<TEntity, TComponent>> idProperty) where TComponent : class
@@ -64,6 +66,18 @@
 			idMapper(new ComponentAsIdCustomizer<TComponent>(ExplicitDeclarationsHolder, CustomizersHolder, propertyPath));
 		}
 
+		public void ComponentAsId<TComponent>(string notVidiblePropertyOrFieldName) where TComponent : class
+		{
+			ComponentAsId<TComponent>(notVidiblePropertyOrFieldName, x => { });
+		}
+
+		public void ComponentAsId<TComponent>(string notVidiblePropertyOrFieldName, Action<IComponentAsIdMapper<TComponent>> idMapper) where TComponent : class
+		{
+			var member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			var propertyPath = new PropertyPath(null, member);
+			idMapper(new ComponentAsIdCustomizer<TComponent>(ExplicitDeclarationsHolder, CustomizersHolder, propertyPath));
+		}
+
 		public void ComposedId(Action<IComposedIdMapper<TEntity>> idPropertiesMapping)
 		{
 			idPropertiesMapping(new ComposedIdCustomizer<TEntity>(ExplicitDeclarationsHolder, CustomizersHolder));
@@ -110,6 +124,13 @@
 			CustomizersHolder.AddCustomizer(typeof(TEntity), (IClassMapper m) => m.Version(member, versionMapping));
 		}
 
+		public void Version(string notVidiblePropertyOrFieldName, Action<IVersionMapper> versionMapping)
+		{
+			var member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			ExplicitDeclarationsHolder.AddAsVersionProperty(member);
+			CustomizersHolder.AddCustomizer(typeof(TEntity), (IClassMapper m) => m.Version(member, versionMapping));
+		}
+
 		public void NaturalId(Action<IBasePlainPropertyContainerMapper<TEntity>> naturalIdPropertiesMapping, Action<INaturalIdAttributesMapper> naturalIdMapping)
 		{
 			naturalIdPropertiesMapping(new NaturalIdCustomizer<TEntity>(ExplicitDeclarationsHolder, CustomizersHolder));

Modified: trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/MappingOfPrivateMembersOnRootEntity.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/MappingOfPrivateMembersOnRootEntity.cs	2011-04-29 21:16:22 UTC (rev 5790)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/MappingOfPrivateMembersOnRootEntity.cs	2011-04-29 21:31:40 UTC (rev 5791)
@@ -11,6 +11,7 @@
 		public class MyClass
 		{
 			private int id;
+			private int version;
 			private string something;
 		}
 
@@ -20,11 +21,12 @@
 			var mapper = new ModelMapper();
 			mapper.Class<MyClass>(ca =>
 			{
-				ca.Id(ForClass<MyClass>.Field("id"), map =>
+				ca.Id("id", map =>
 				{
 					map.Column("MyClassId");
 					map.Generator(Generators.HighLow, gmap => gmap.Params(new { max_low = 100 }));
 				});
+				ca.Version("version", map => { });
 				ca.Property("something", map => map.Length(150));
 			});
 			var hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClass) });
@@ -39,6 +41,8 @@
 			hbm...@cl...().Be("hilo");
 			hbmGenerator.param[0].name.Should().Be("max_low");
 			hbmGenerator.param[0].GetText().Should().Be("100");
+			var hbmVersion = hbmClass.Version;
+			hbmVersion.name.Should().Be("version");
 			var hbmProperty = hbmClass.Properties.OfType<HbmProperty>().Single();
 			hbmProperty.name.Should().Be("something");
 			hbmProperty.access.Should().Be("field");


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5790] trunk/nhibernate/src/NHibernate

[<fab...@us...>]

Revision: 5790
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5790&view=rev
Author:   fabiomaulo
Date:     2011-04-29 21:16:22 +0000 (Fri, 29 Apr 2011)

Log Message:
-----------
Customizers with mapping of not visible members

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/IPlainPropertyContainerMapper.cs
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/IPropertyContainerMapper.cs
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/PropertyContainerCustomizer.cs
    trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj

Added Paths:
-----------
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/AllPropertiesRegistrationTests.cs

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/IPlainPropertyContainerMapper.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/IPlainPropertyContainerMapper.cs	2011-04-29 18:28:17 UTC (rev 5789)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/IPlainPropertyContainerMapper.cs	2011-04-29 21:16:22 UTC (rev 5790)
@@ -32,6 +32,7 @@
 
 		void ManyToOne<TProperty>(Expression<Func<TContainer, TProperty>> property, Action<IManyToOneMapper> mapping) where TProperty : class;
 		void ManyToOne<TProperty>(Expression<Func<TContainer, TProperty>> property) where TProperty : class;
+		void ManyToOne<TProperty>(string notVidiblePropertyOrFieldName, Action<IManyToOneMapper> mapping) where TProperty : class;
 	}
 
 	public interface IBasePlainPropertyContainerMapper<TContainer> : IMinimalPlainPropertyContainerMapper<TContainer>
@@ -39,16 +40,24 @@
 		void Component<TComponent>(Expression<Func<TContainer, TComponent>> property,
 															 Action<IComponentMapper<TComponent>> mapping) where TComponent : class;
 		void Component<TComponent>(Expression<Func<TContainer, TComponent>> property) where TComponent : class;
-
 		void Component<TComponent>(Expression<Func<TContainer, IDictionary>> property,
 		                           TComponent dynamicComponentTemplate,
 		                           Action<IDynamicComponentMapper<TComponent>> mapping) where TComponent : class;
 
+		void Component<TComponent>(string notVidiblePropertyOrFieldName,
+															 Action<IComponentMapper<TComponent>> mapping) where TComponent : class;
+		void Component<TComponent>(string notVidiblePropertyOrFieldName) where TComponent : class;
+		void Component<TComponent>(string notVidiblePropertyOrFieldName,
+															 TComponent dynamicComponentTemplate,
+															 Action<IDynamicComponentMapper<TComponent>> mapping) where TComponent : class;
+
 		void Any<TProperty>(Expression<Func<TContainer, TProperty>> property, System.Type idTypeOfMetaType, Action<IAnyMapper> mapping) where TProperty : class;
+		void Any<TProperty>(string notVidiblePropertyOrFieldName, System.Type idTypeOfMetaType, Action<IAnyMapper> mapping) where TProperty : class;
 	}
 
 	public interface IPlainPropertyContainerMapper<TContainer> : IBasePlainPropertyContainerMapper<TContainer>
 	{
 		void OneToOne<TProperty>(Expression<Func<TContainer, TProperty>> property, Action<IOneToOneMapper> mapping) where TProperty : class;
+		void OneToOne<TProperty>(string notVidiblePropertyOrFieldName, Action<IOneToOneMapper> mapping) where TProperty : class;
 	}
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/IPropertyContainerMapper.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/IPropertyContainerMapper.cs	2011-04-29 18:28:17 UTC (rev 5789)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/IPropertyContainerMapper.cs	2011-04-29 21:16:22 UTC (rev 5790)
@@ -33,35 +33,63 @@
 		                   Action<ICollectionElementRelation<TElement>> mapping);
 		void Set<TElement>(Expression<Func<TEntity, IEnumerable<TElement>>> property,
 											 Action<ISetPropertiesMapper<TEntity, TElement>> collectionMapping);
+		void Set<TElement>(string notVidiblePropertyOrFieldName,
+											 Action<ISetPropertiesMapper<TEntity, TElement>> collectionMapping,
+											 Action<ICollectionElementRelation<TElement>> mapping);
+		void Set<TElement>(string notVidiblePropertyOrFieldName,
+											 Action<ISetPropertiesMapper<TEntity, TElement>> collectionMapping);
 
 		void Bag<TElement>(Expression<Func<TEntity, IEnumerable<TElement>>> property,
 		                   Action<IBagPropertiesMapper<TEntity, TElement>> collectionMapping,
 		                   Action<ICollectionElementRelation<TElement>> mapping);
 		void Bag<TElement>(Expression<Func<TEntity, IEnumerable<TElement>>> property,
 											 Action<IBagPropertiesMapper<TEntity, TElement>> collectionMapping);
+		void Bag<TElement>(string notVidiblePropertyOrFieldName,
+											 Action<IBagPropertiesMapper<TEntity, TElement>> collectionMapping,
+											 Action<ICollectionElementRelation<TElement>> mapping);
+		void Bag<TElement>(string notVidiblePropertyOrFieldName,
+											 Action<IBagPropertiesMapper<TEntity, TElement>> collectionMapping);
 
 		void List<TElement>(Expression<Func<TEntity, IEnumerable<TElement>>> property,
 		                    Action<IListPropertiesMapper<TEntity, TElement>> collectionMapping,
 		                    Action<ICollectionElementRelation<TElement>> mapping);
 		void List<TElement>(Expression<Func<TEntity, IEnumerable<TElement>>> property,
 												Action<IListPropertiesMapper<TEntity, TElement>> collectionMapping);
+		void List<TElement>(string notVidiblePropertyOrFieldName,
+												Action<IListPropertiesMapper<TEntity, TElement>> collectionMapping,
+												Action<ICollectionElementRelation<TElement>> mapping);
+		void List<TElement>(string notVidiblePropertyOrFieldName,
+												Action<IListPropertiesMapper<TEntity, TElement>> collectionMapping);
 
 		void Map<TKey, TElement>(Expression<Func<TEntity, IDictionary<TKey, TElement>>> property,
 		                         Action<IMapPropertiesMapper<TEntity, TKey, TElement>> collectionMapping,
 		                         Action<IMapKeyRelation<TKey>> keyMapping,
 		                         Action<ICollectionElementRelation<TElement>> mapping);
-
 		void Map<TKey, TElement>(Expression<Func<TEntity, IDictionary<TKey, TElement>>> property,
 		                         Action<IMapPropertiesMapper<TEntity, TKey, TElement>> collectionMapping,
 		                         Action<ICollectionElementRelation<TElement>> mapping);
 		void Map<TKey, TElement>(Expression<Func<TEntity, IDictionary<TKey, TElement>>> property,
 														 Action<IMapPropertiesMapper<TEntity, TKey, TElement>> collectionMapping);
+		void Map<TKey, TElement>(string notVidiblePropertyOrFieldName,
+												 Action<IMapPropertiesMapper<TEntity, TKey, TElement>> collectionMapping,
+												 Action<IMapKeyRelation<TKey>> keyMapping,
+												 Action<ICollectionElementRelation<TElement>> mapping);
+		void Map<TKey, TElement>(string notVidiblePropertyOrFieldName,
+														 Action<IMapPropertiesMapper<TEntity, TKey, TElement>> collectionMapping,
+														 Action<ICollectionElementRelation<TElement>> mapping);
+		void Map<TKey, TElement>(string notVidiblePropertyOrFieldName,
+														 Action<IMapPropertiesMapper<TEntity, TKey, TElement>> collectionMapping);
 
 		void IdBag<TElement>(Expression<Func<TEntity, IEnumerable<TElement>>> property,
 											 Action<IIdBagPropertiesMapper<TEntity, TElement>> collectionMapping,
 											 Action<ICollectionElementRelation<TElement>> mapping);
 		void IdBag<TElement>(Expression<Func<TEntity, IEnumerable<TElement>>> property,
 											 Action<IIdBagPropertiesMapper<TEntity, TElement>> collectionMapping);
+		void IdBag<TElement>(string notVidiblePropertyOrFieldName,
+											 Action<IIdBagPropertiesMapper<TEntity, TElement>> collectionMapping,
+											 Action<ICollectionElementRelation<TElement>> mapping);
+		void IdBag<TElement>(string notVidiblePropertyOrFieldName,
+											 Action<IIdBagPropertiesMapper<TEntity, TElement>> collectionMapping);
 	}
 
 	public interface IPropertyContainerMapper<TEntity> : ICollectionPropertiesContainerMapper<TEntity>, IPlainPropertyContainerMapper<TEntity> where TEntity : class {}

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/PropertyContainerCustomizer.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/PropertyContainerCustomizer.cs	2011-04-29 18:28:17 UTC (rev 5789)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/PropertyContainerCustomizer.cs	2011-04-29 21:16:22 UTC (rev 5790)
@@ -43,10 +43,7 @@
 		{
 			MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
 			MemberInfo memberOf = TypeExtensions.DecodeMemberAccessExpressionOf(property);
-			CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, member), mapping);
-			CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, memberOf), mapping);
-			explicitDeclarationsHolder.AddAsProperty(member);
-			explicitDeclarationsHolder.AddAsProperty(memberOf);
+			RegistePropertyMapping(mapping, member, memberOf);
 		}
 
 		public void Property(string notVidiblePropertyOrFieldName, Action<IPropertyMapper> mapping)
@@ -60,12 +57,18 @@
 			// done unsing expressions are faster than those done with pure reflection.
 			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
 			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
-			CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, member), mapping);
-			CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, memberOf), mapping);
-			explicitDeclarationsHolder.AddAsProperty(member);
-			explicitDeclarationsHolder.AddAsProperty(memberOf);
+			RegistePropertyMapping(mapping, member, memberOf);
 		}
 
+		protected void RegistePropertyMapping(Action<IPropertyMapper> mapping, params MemberInfo[] members)
+		{
+			foreach (var member in members)
+			{
+				CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, member), mapping);
+				explicitDeclarationsHolder.AddAsProperty(member);
+			}
+		}
+
 		public void Component<TComponent>(Expression<Func<TEntity, TComponent>> property,
 		                                  Action<IComponentMapper<TComponent>> mapping) where TComponent : class
 		{
@@ -80,11 +83,19 @@
 			where TComponent : class
 		{
 			MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
-			mapping(new ComponentCustomizer<TComponent>(explicitDeclarationsHolder, CustomizersHolder, new PropertyPath(PropertyPath, member)));
 			MemberInfo memberOf = TypeExtensions.DecodeMemberAccessExpressionOf(property);
-			mapping(new ComponentCustomizer<TComponent>(explicitDeclarationsHolder, CustomizersHolder, new PropertyPath(PropertyPath, memberOf)));
+			RegisterComponentMapping<TComponent>(mapping, member, memberOf);
 		}
 
+		protected void RegisterComponentMapping<TComponent>(Action<IComponentMapper<TComponent>> mapping, params MemberInfo[] members)
+			where TComponent : class
+		{
+			foreach (var member in members)
+			{
+				mapping(new ComponentCustomizer<TComponent>(explicitDeclarationsHolder, CustomizersHolder, new PropertyPath(PropertyPath, member)));
+			}
+		}
+
 		public void Component<TComponent>(Expression<Func<TEntity, IDictionary>> property,
 													 TComponent dynamicComponentTemplate,
 													 Action<IDynamicComponentMapper<TComponent>> mapping) where TComponent : class
@@ -95,11 +106,19 @@
 		protected virtual void RegisterDynamicComponentMapping<TComponent>(Expression<Func<TEntity, IDictionary>> property, Action<IDynamicComponentMapper<TComponent>> mapping) where TComponent : class
 		{
 			MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
-			mapping(new DynamicComponentCustomizer<TComponent>(explicitDeclarationsHolder, CustomizersHolder, new PropertyPath(PropertyPath, member)));
 			MemberInfo memberOf = TypeExtensions.DecodeMemberAccessExpressionOf(property);
-			mapping(new DynamicComponentCustomizer<TComponent>(explicitDeclarationsHolder, CustomizersHolder, new PropertyPath(PropertyPath, memberOf)));
+			RegisterDynamicComponentMapping<TComponent>(mapping, member, memberOf);
 		}
 
+		protected void RegisterDynamicComponentMapping<TComponent>(Action<IDynamicComponentMapper<TComponent>> mapping, params MemberInfo[] members)
+			where TComponent : class
+		{
+			foreach (var member in members)
+			{
+				mapping(new DynamicComponentCustomizer<TComponent>(explicitDeclarationsHolder, CustomizersHolder, new PropertyPath(PropertyPath, member)));
+			}
+		}
+
 		public void ManyToOne<TProperty>(Expression<Func<TEntity, TProperty>> property, Action<IManyToOneMapper> mapping)
 			where TProperty : class
 		{
@@ -110,13 +129,20 @@
 			where TProperty : class
 		{
 			MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
-			CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, member), mapping);
 			MemberInfo memberOf = TypeExtensions.DecodeMemberAccessExpressionOf(property);
-			CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, memberOf), mapping);
-			explicitDeclarationsHolder.AddAsManyToOneRelation(member);
-			explicitDeclarationsHolder.AddAsManyToOneRelation(memberOf);
+			RegisterManyToOneMapping<TProperty>(mapping, member, memberOf);
 		}
 
+		protected void RegisterManyToOneMapping<TProperty>(Action<IManyToOneMapper> mapping, params MemberInfo[] members)
+			where TProperty : class
+		{
+			foreach (var member in members)
+			{
+				CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, member), mapping);
+				explicitDeclarationsHolder.AddAsManyToOneRelation(member);
+			}
+		}
+
 		public void ManyToOne<TProperty>(Expression<Func<TEntity, TProperty>> property) where TProperty : class
 		{
 			ManyToOne(property, x => { });
@@ -126,13 +152,20 @@
 			where TProperty : class
 		{
 			MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
-			CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, member), mapping);
 			MemberInfo memberOf = TypeExtensions.DecodeMemberAccessExpressionOf(property);
-			CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, memberOf), mapping);
-			explicitDeclarationsHolder.AddAsOneToOneRelation(member);
-			explicitDeclarationsHolder.AddAsOneToOneRelation(memberOf);
+			RegisterOneToOneMapping<TProperty>(mapping, member, memberOf);
 		}
 
+		protected void RegisterOneToOneMapping<TProperty>(Action<IOneToOneMapper> mapping, params MemberInfo[] members)
+			where TProperty : class
+		{
+			foreach (var member in members)
+			{
+				CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, member), mapping);
+				explicitDeclarationsHolder.AddAsOneToOneRelation(member);
+			}
+		}
+
 		public void Any<TProperty>(Expression<Func<TEntity, TProperty>> property, System.Type idTypeOfMetaType, Action<IAnyMapper> mapping)
 			where TProperty : class
 		{
@@ -143,15 +176,22 @@
 			where TProperty : class
 		{
 			MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
-			CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, member), am => am.IdType(idTypeOfMetaType));
-			CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, member), mapping);
 			MemberInfo memberOf = TypeExtensions.DecodeMemberAccessExpressionOf(property);
-			CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, memberOf), mapping);
-			CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, memberOf), am => am.IdType(idTypeOfMetaType));
-			explicitDeclarationsHolder.AddAsAny(member);
-			explicitDeclarationsHolder.AddAsAny(memberOf);
+			RegisterAnyMapping<TProperty>(mapping, idTypeOfMetaType, member, memberOf);
 		}
 
+		protected void RegisterAnyMapping<TProperty>(Action<IAnyMapper> mapping, System.Type idTypeOfMetaType, params MemberInfo[] members)
+			where TProperty : class
+		{
+			foreach (var member in members)
+			{
+				CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, member), am => am.IdType(idTypeOfMetaType));
+				CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, member), mapping);
+
+				explicitDeclarationsHolder.AddAsAny(member);
+			}
+		}
+
 		public void Set<TElement>(Expression<Func<TEntity, IEnumerable<TElement>>> property,
 		                          Action<ISetPropertiesMapper<TEntity, TElement>> collectionMapping,
 		                          Action<ICollectionElementRelation<TElement>> mapping)
@@ -168,14 +208,19 @@
 		protected virtual void RegisterSetMapping<TElement>(Expression<Func<TEntity, IEnumerable<TElement>>> property, Action<ISetPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping)
 		{
 			MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
-			collectionMapping(new SetPropertiesCustomizer<TEntity, TElement>(explicitDeclarationsHolder, new PropertyPath(null, member), CustomizersHolder));
-			mapping(new CollectionElementRelationCustomizer<TElement>(explicitDeclarationsHolder, new PropertyPath(PropertyPath, member), CustomizersHolder));
-
 			MemberInfo memberOf = TypeExtensions.DecodeMemberAccessExpressionOf(property);
-			collectionMapping(new SetPropertiesCustomizer<TEntity, TElement>(explicitDeclarationsHolder, new PropertyPath(null, memberOf), CustomizersHolder));
-			mapping(new CollectionElementRelationCustomizer<TElement>(explicitDeclarationsHolder, new PropertyPath(PropertyPath, member), CustomizersHolder));
+			RegisterSetMapping<TElement>(collectionMapping, mapping, member, memberOf);
 		}
 
+		protected void RegisterSetMapping<TElement>(Action<ISetPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping, params MemberInfo[] members)
+		{
+			foreach (var member in members)
+			{
+				collectionMapping(new SetPropertiesCustomizer<TEntity, TElement>(explicitDeclarationsHolder, new PropertyPath(null, member), CustomizersHolder));
+				mapping(new CollectionElementRelationCustomizer<TElement>(explicitDeclarationsHolder, new PropertyPath(PropertyPath, member), CustomizersHolder));
+			}
+		}
+
 		public void Bag<TElement>(Expression<Func<TEntity, IEnumerable<TElement>>> property,
 		                          Action<IBagPropertiesMapper<TEntity, TElement>> collectionMapping,
 		                          Action<ICollectionElementRelation<TElement>> mapping)
@@ -191,14 +236,19 @@
 		protected virtual void RegisterBagMapping<TElement>(Expression<Func<TEntity, IEnumerable<TElement>>> property, Action<IBagPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping)
 		{
 			MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
-			collectionMapping(new BagPropertiesCustomizer<TEntity, TElement>(explicitDeclarationsHolder, new PropertyPath(null, member), CustomizersHolder));
-			mapping(new CollectionElementRelationCustomizer<TElement>(explicitDeclarationsHolder, new PropertyPath(PropertyPath, member), CustomizersHolder));
-
 			MemberInfo memberOf = TypeExtensions.DecodeMemberAccessExpressionOf(property);
-			collectionMapping(new BagPropertiesCustomizer<TEntity, TElement>(explicitDeclarationsHolder, new PropertyPath(null, memberOf), CustomizersHolder));
-			mapping(new CollectionElementRelationCustomizer<TElement>(explicitDeclarationsHolder, new PropertyPath(PropertyPath, memberOf), CustomizersHolder));
+			RegisterBagMapping<TElement>(collectionMapping, mapping, member, memberOf);
 		}
 
+		protected void RegisterBagMapping<TElement>(Action<IBagPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping, params MemberInfo[] members)
+		{
+			foreach (var member in members)
+			{
+				collectionMapping(new BagPropertiesCustomizer<TEntity, TElement>(explicitDeclarationsHolder, new PropertyPath(null, member), CustomizersHolder));
+				mapping(new CollectionElementRelationCustomizer<TElement>(explicitDeclarationsHolder, new PropertyPath(PropertyPath, member), CustomizersHolder));
+			}
+		}
+
 		public void List<TElement>(Expression<Func<TEntity, IEnumerable<TElement>>> property,
 		                           Action<IListPropertiesMapper<TEntity, TElement>> collectionMapping,
 		                           Action<ICollectionElementRelation<TElement>> mapping)
@@ -214,14 +264,19 @@
 		protected virtual void RegisterListMapping<TElement>(Expression<Func<TEntity, IEnumerable<TElement>>> property, Action<IListPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping)
 		{
 			MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
-			collectionMapping(new ListPropertiesCustomizer<TEntity, TElement>(explicitDeclarationsHolder, new PropertyPath(null, member), CustomizersHolder));
-			mapping(new CollectionElementRelationCustomizer<TElement>(explicitDeclarationsHolder, new PropertyPath(PropertyPath, member), CustomizersHolder));
-
 			MemberInfo memberOf = TypeExtensions.DecodeMemberAccessExpressionOf(property);
-			collectionMapping(new ListPropertiesCustomizer<TEntity, TElement>(explicitDeclarationsHolder, new PropertyPath(null, memberOf), CustomizersHolder));
-			mapping(new CollectionElementRelationCustomizer<TElement>(explicitDeclarationsHolder, new PropertyPath(PropertyPath, member), CustomizersHolder));
+			RegisterListMapping<TElement>(collectionMapping, mapping, member, memberOf);
 		}
 
+		protected void RegisterListMapping<TElement>(Action<IListPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping, params MemberInfo[] members)
+		{
+			foreach (var member in members)
+			{
+				collectionMapping(new ListPropertiesCustomizer<TEntity, TElement>(explicitDeclarationsHolder, new PropertyPath(null, member), CustomizersHolder));
+				mapping(new CollectionElementRelationCustomizer<TElement>(explicitDeclarationsHolder, new PropertyPath(PropertyPath, member), CustomizersHolder));
+			}
+		}
+
 		public void Map<TKey, TElement>(Expression<Func<TEntity, IDictionary<TKey, TElement>>> property,
 		                                Action<IMapPropertiesMapper<TEntity, TKey, TElement>> collectionMapping,
 		                                Action<IMapKeyRelation<TKey>> keyMapping,
@@ -238,18 +293,21 @@
 		protected virtual void RegisterMapMapping<TKey, TElement>(Expression<Func<TEntity, IDictionary<TKey, TElement>>> property, Action<IMapPropertiesMapper<TEntity, TKey, TElement>> collectionMapping, Action<IMapKeyRelation<TKey>> keyMapping, Action<ICollectionElementRelation<TElement>> mapping)
 		{
 			MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
-			var memberPath = new PropertyPath(PropertyPath, member);
-			collectionMapping(new MapPropertiesCustomizer<TEntity, TKey, TElement>(explicitDeclarationsHolder, memberPath, CustomizersHolder));
-			keyMapping(new MapKeyRelationCustomizer<TKey>(explicitDeclarationsHolder, memberPath, CustomizersHolder));
-			mapping(new CollectionElementRelationCustomizer<TElement>(explicitDeclarationsHolder, memberPath, CustomizersHolder));
-
 			MemberInfo memberOf = TypeExtensions.DecodeMemberAccessExpressionOf(property);
-			var memberOfPath = new PropertyPath(PropertyPath, memberOf);
-			collectionMapping(new MapPropertiesCustomizer<TEntity, TKey, TElement>(explicitDeclarationsHolder, memberOfPath, CustomizersHolder));
-			keyMapping(new MapKeyRelationCustomizer<TKey>(explicitDeclarationsHolder, memberOfPath, CustomizersHolder));
-			mapping(new CollectionElementRelationCustomizer<TElement>(explicitDeclarationsHolder, memberOfPath, CustomizersHolder));
+			RegisterMapMapping<TKey, TElement>(collectionMapping, keyMapping, mapping, member, memberOf);
 		}
 
+		protected virtual void RegisterMapMapping<TKey, TElement>(Action<IMapPropertiesMapper<TEntity, TKey, TElement>> collectionMapping, Action<IMapKeyRelation<TKey>> keyMapping, Action<ICollectionElementRelation<TElement>> mapping, params MemberInfo[] members)
+		{
+			foreach (var member in members)
+			{
+				var memberPath = new PropertyPath(PropertyPath, member);
+				collectionMapping(new MapPropertiesCustomizer<TEntity, TKey, TElement>(explicitDeclarationsHolder, memberPath, CustomizersHolder));
+				keyMapping(new MapKeyRelationCustomizer<TKey>(explicitDeclarationsHolder, memberPath, CustomizersHolder));
+				mapping(new CollectionElementRelationCustomizer<TElement>(explicitDeclarationsHolder, memberPath, CustomizersHolder));
+			}
+		}
+
 		public void Map<TKey, TElement>(Expression<Func<TEntity, IDictionary<TKey, TElement>>> property,
 																		Action<IMapPropertiesMapper<TEntity, TKey, TElement>> collectionMapping,
 																		Action<ICollectionElementRelation<TElement>> mapping)
@@ -273,12 +331,122 @@
 		protected virtual void RegisterIdBagMapping<TElement>(Expression<Func<TEntity, IEnumerable<TElement>>> property, Action<IIdBagPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping)
 		{
 			MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
-			collectionMapping(new IdBagPropertiesCustomizer<TEntity, TElement>(explicitDeclarationsHolder, new PropertyPath(null, member), CustomizersHolder));
-			mapping(new CollectionElementRelationCustomizer<TElement>(explicitDeclarationsHolder, new PropertyPath(PropertyPath, member), CustomizersHolder));
-
 			MemberInfo memberOf = TypeExtensions.DecodeMemberAccessExpressionOf(property);
-			collectionMapping(new IdBagPropertiesCustomizer<TEntity, TElement>(explicitDeclarationsHolder, new PropertyPath(null, memberOf), CustomizersHolder));
-			mapping(new CollectionElementRelationCustomizer<TElement>(explicitDeclarationsHolder, new PropertyPath(PropertyPath, memberOf), CustomizersHolder));
+			RegisterIdBagMapping<TElement>(collectionMapping, mapping, member, memberOf);
 		}
+
+		protected virtual void RegisterIdBagMapping<TElement>(Action<IIdBagPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping,params MemberInfo[] members)
+		{
+			foreach (var member in members)
+			{
+				collectionMapping(new IdBagPropertiesCustomizer<TEntity, TElement>(explicitDeclarationsHolder, new PropertyPath(null, member), CustomizersHolder));
+				mapping(new CollectionElementRelationCustomizer<TElement>(explicitDeclarationsHolder, new PropertyPath(PropertyPath, member), CustomizersHolder));
+			}
+		}
+
+		public void Set<TElement>(string notVidiblePropertyOrFieldName, Action<ISetPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping)
+		{
+			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
+			RegisterSetMapping<TElement>(collectionMapping, mapping, member, memberOf);
+		}
+
+		public void Set<TElement>(string notVidiblePropertyOrFieldName, Action<ISetPropertiesMapper<TEntity, TElement>> collectionMapping)
+		{
+			Set(notVidiblePropertyOrFieldName, collectionMapping, x => { });
+		}
+
+		public void Bag<TElement>(string notVidiblePropertyOrFieldName, Action<IBagPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping)
+		{
+			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
+			RegisterBagMapping<TElement>(collectionMapping, mapping, member, memberOf);
+		}
+
+		public void Bag<TElement>(string notVidiblePropertyOrFieldName, Action<IBagPropertiesMapper<TEntity, TElement>> collectionMapping)
+		{
+			Bag(notVidiblePropertyOrFieldName, collectionMapping, x => { });
+		}
+
+		public void List<TElement>(string notVidiblePropertyOrFieldName, Action<IListPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping)
+		{
+			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
+			RegisterListMapping<TElement>(collectionMapping, mapping, member, memberOf);
+		}
+
+		public void List<TElement>(string notVidiblePropertyOrFieldName, Action<IListPropertiesMapper<TEntity, TElement>> collectionMapping)
+		{
+			List(notVidiblePropertyOrFieldName, collectionMapping, x => { });
+		}
+
+		public void Map<TKey, TElement>(string notVidiblePropertyOrFieldName, Action<IMapPropertiesMapper<TEntity, TKey, TElement>> collectionMapping, Action<IMapKeyRelation<TKey>> keyMapping, Action<ICollectionElementRelation<TElement>> mapping)
+		{
+			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
+			RegisterMapMapping<TKey, TElement>(collectionMapping, keyMapping, mapping, member, memberOf);
+		}
+
+		public void Map<TKey, TElement>(string notVidiblePropertyOrFieldName, Action<IMapPropertiesMapper<TEntity, TKey, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping)
+		{
+			Map(notVidiblePropertyOrFieldName, collectionMapping, x => { }, mapping);
+		}
+
+		public void Map<TKey, TElement>(string notVidiblePropertyOrFieldName, Action<IMapPropertiesMapper<TEntity, TKey, TElement>> collectionMapping)
+		{
+			Map(notVidiblePropertyOrFieldName, collectionMapping, x => { }, y => { });
+		}
+
+		public void IdBag<TElement>(string notVidiblePropertyOrFieldName, Action<IIdBagPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping)
+		{
+			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
+			RegisterIdBagMapping<TElement>(collectionMapping, mapping, member, memberOf);
+		}
+
+		public void IdBag<TElement>(string notVidiblePropertyOrFieldName, Action<IIdBagPropertiesMapper<TEntity, TElement>> collectionMapping)
+		{
+			IdBag(notVidiblePropertyOrFieldName, collectionMapping, x => { });
+		}
+
+		public void ManyToOne<TProperty>(string notVidiblePropertyOrFieldName, Action<IManyToOneMapper> mapping) where TProperty : class
+		{
+			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
+			RegisterManyToOneMapping<TProperty>(mapping, member, memberOf);
+		}
+
+		public void Component<TComponent>(string notVidiblePropertyOrFieldName, Action<IComponentMapper<TComponent>> mapping) where TComponent : class
+		{
+			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
+			RegisterComponentMapping<TComponent>(mapping, member, memberOf);
+		}
+
+		public void Component<TComponent>(string notVidiblePropertyOrFieldName) where TComponent : class
+		{
+			Component<TComponent>(notVidiblePropertyOrFieldName, x => { });
+		}
+
+		public void Component<TComponent>(string notVidiblePropertyOrFieldName, TComponent dynamicComponentTemplate, Action<IDynamicComponentMapper<TComponent>> mapping) where TComponent : class
+		{
+			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
+			RegisterDynamicComponentMapping<TComponent>(mapping, member, memberOf);
+		}
+
+		public void Any<TProperty>(string notVidiblePropertyOrFieldName, System.Type idTypeOfMetaType, Action<IAnyMapper> mapping) where TProperty : class
+		{
+			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
+			RegisterAnyMapping<TProperty>(mapping, idTypeOfMetaType, member, memberOf);
+		}
+
+		public void OneToOne<TProperty>(string notVidiblePropertyOrFieldName, Action<IOneToOneMapper> mapping) where TProperty : class
+		{
+			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
+			RegisterOneToOneMapping<TProperty>(mapping, member, memberOf);
+		}
 	}
 }
\ No newline at end of file

Added: trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/AllPropertiesRegistrationTests.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/AllPropertiesRegistrationTests.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/AllPropertiesRegistrationTests.cs	2011-04-29 21:16:22 UTC (rev 5790)
@@ -0,0 +1,260 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using NHibernate.Cfg.MappingSchema;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+using SharpTestsEx;
+
+namespace NHibernate.Test.MappingByCode.ExpliticMappingTests
+{
+	public class AllPropertiesRegistrationTests
+	{
+		private class MyClass
+		{
+			public int Id { get; set; }
+			private int simple;
+			public int Simple
+			{
+				get { return simple; }
+				set { simple = value; }
+			}
+
+			private IList<string> complexType;
+			public IList<string> ComplexType
+			{
+				get { return complexType; }
+				set { complexType = value; }
+			}
+
+			private IEnumerable<string> bag;
+			public IEnumerable<string> Bag
+			{
+				get { return bag; }
+				set { bag = value; }
+			}
+
+			private IEnumerable<MyCompo> idBag;
+			public IEnumerable<MyCompo> IdBag
+			{
+				get { return idBag; }
+				set { idBag = value; }
+			}
+
+			private IEnumerable<string> set;
+			public IEnumerable<string> Set
+			{
+				get { return set; }
+				set { set = value; }
+			}
+
+			private IEnumerable<string> list;
+			public IEnumerable<string> List
+			{
+				get { return list; }
+				set { list = value; }
+			}
+
+			private IDictionary<int, string> map;
+			public IDictionary<int, string> Map
+			{
+				get { return map; }
+				set { map = value; }
+			}
+
+			private MyCompo compo;
+			public MyCompo Compo
+			{
+				get { return compo; }
+				set { compo = value; }
+			}
+
+			private Related oneToOne;
+			public Related OneToOne
+			{
+				get { return oneToOne; }
+				set { oneToOne = value; }
+			}
+
+			private Related manyToOne;
+			public Related ManyToOne
+			{
+				get { return manyToOne; }
+				set { manyToOne = value; }
+			}
+
+			private object any;
+			public object Any
+			{
+				get { return any; }
+				set { any = value; }
+			}
+
+			private IDictionary dynamicCompo;
+			public IDictionary DynamicCompo
+			{
+				get { return dynamicCompo; }
+				set { dynamicCompo = value; }
+			}
+		}
+
+		private class MyCompo
+		{
+			public int Something { get; set; }
+		}
+		private class Related
+		{
+			public int  Id { get; set; }
+		}
+
+		private class Inherited:MyClass
+		{
+			
+		}
+
+		[Test]
+		public void WhenMapPropertiesInTheInheritedThenMapInBase()
+		{
+			// without ignoring MyClass as root-class I will try to map all properties using the inherited class.
+			// NH have to recognize the case and, following Object-Relational-Mapping rules, map those properties in the base class.
+			// Where needed, using the SimpleModelInspector, the user can revert this behavior checking the DeclaringType and ReflectedType of the persistent member.
+			var mapper = new ModelMapper();
+			mapper.Class<MyClass>(mc => mc.Id(x => x.Id));
+			mapper.JoinedSubclass<Inherited>(mc =>
+														{
+															mc.Property(x => x.Simple, map => map.Access(Accessor.Field));
+															mc.Property(x => x.ComplexType, map => map.Access(Accessor.Field));
+															mc.Bag(x => x.Bag, y => y.Access(Accessor.Field));
+															mc.IdBag(x => x.IdBag, y => y.Access(Accessor.Field));
+															mc.List(x => x.List, y => y.Access(Accessor.Field));
+															mc.Set(x => x.Set, y => y.Access(Accessor.Field));
+															mc.Map(x => x.Map, y => y.Access(Accessor.Field));
+															mc.OneToOne(x => x.OneToOne, y => y.Access(Accessor.Field));
+															mc.ManyToOne(x => x.ManyToOne, y => y.Access(Accessor.Field));
+															mc.Any(x => x.Any, typeof(int), y => y.Access(Accessor.Field));
+															mc.Component(x => x.DynamicCompo, new { A=2 }, y => y.Access(Accessor.Field));
+															mc.Component(x => x.Compo, y =>
+																												 {
+																													 y.Access(Accessor.Field);
+																													 y.Property(c => c.Something);
+																												 });
+														});
+			var mappings = mapper.CompileMappingForAllExplicitAddedEntities();
+			var hbmClass = mappings.RootClasses[0];
+			var hbmJoinedSubclass = mappings.JoinedSubclasses[0];
+			hbmClass.Properties.Select(p => p.Name).Should().Have.SameValuesAs("Simple", "ComplexType", "Bag", "IdBag", "List", "Set", "Map", "Compo", "OneToOne", "ManyToOne", "Any", "DynamicCompo");
+			hbmClass.Properties.Select(p => p.Access).All(x=> x.Satisfy(access=> access.Contains("field.")));
+			hbmJoinedSubclass.Properties.Should().Be.Empty();
+		}
+
+		[Test]
+		public void WhenMapPropertiesInTheBaseJumpedClassThenMapInInherited()
+		{
+			// ignoring MyClass and using Inherited, as root-class, I will try to map all properties using the base class.
+			// NH have to recognize the case and map those properties in the inherited.
+			var inspector = new SimpleModelInspector();
+			inspector.IsRootEntity((type, declared) => type == typeof(Inherited));
+			var mapper = new ModelMapper();
+			mapper.Class<MyClass>(mc =>
+			                      {
+			                      	mc.Id(x => x.Id);
+			                      	mc.Property(x => x.Simple, map => map.Access(Accessor.Field));
+			                      	mc.Property(x => x.ComplexType, map => map.Access(Accessor.Field));
+			                      	mc.Bag(x => x.Bag, y => y.Access(Accessor.Field));
+			                      	mc.IdBag(x => x.IdBag, y => y.Access(Accessor.Field));
+			                      	mc.List(x => x.List, y => y.Access(Accessor.Field));
+			                      	mc.Set(x => x.Set, y => y.Access(Accessor.Field));
+			                      	mc.Map(x => x.Map, y => y.Access(Accessor.Field));
+															mc.OneToOne(x => x.OneToOne, y => y.Access(Accessor.Field));
+															mc.ManyToOne(x => x.ManyToOne, y => y.Access(Accessor.Field));
+															mc.Any(x => x.Any, typeof(int), y => y.Access(Accessor.Field));
+															mc.Component(x => x.DynamicCompo, new { A = 2 }, y => y.Access(Accessor.Field));
+															mc.Component(x => x.Compo, y =>
+			                      	                           {
+			                      	                           	y.Access(Accessor.Field);
+			                      	                           	y.Property(c => c.Something);
+			                      	                           });
+			                      });
+			mapper.Class<Inherited>(mc =>{});
+
+			var mappings = mapper.CompileMappingForAllExplicitAddedEntities();
+			var hbmClass = mappings.RootClasses[0];
+			mappings.JoinedSubclasses.Should().Be.Empty();
+			hbmClass.Properties.Select(p => p.Name).Should().Have.SameValuesAs("Simple", "ComplexType", "Bag", "IdBag", "List", "Set", "Map", "Compo", "OneToOne", "ManyToOne", "Any", "DynamicCompo");
+			hbmClass.Properties.Select(p => p.Access).All(x => x.Satisfy(access => access.Contains("field.")));
+		}
+
+		[Test]
+		public void WhenMapPropertiesInTheInheritedUsingMemberNameThenMapInBase()
+		{
+			// without ignoring MyClass as root-class I will try to map all properties using the inherited class.
+			// NH have to recognize the case and, following Object-Relational-Mapping rules, map those properties in the base class.
+			var mapper = new ModelMapper();
+			mapper.Class<MyClass>(mc => mc.Id(x => x.Id));
+			mapper.JoinedSubclass<Inherited>(mc =>
+			                                 {
+			                                 	mc.Property("Simple", map => map.Access(Accessor.Field));
+			                                 	mc.Property("ComplexType", map => map.Access(Accessor.Field));
+			                                 	mc.Bag<string>("Bag", y => y.Access(Accessor.Field));
+			                                 	mc.IdBag<MyCompo>("IdBag", y => y.Access(Accessor.Field));
+																				mc.List<string>("List", y => y.Access(Accessor.Field));
+																				mc.Set<string>("Set", y => y.Access(Accessor.Field));
+																				mc.Map<int, string>("Map", y => y.Access(Accessor.Field));
+																				mc.OneToOne<Related>("OneToOne", y => y.Access(Accessor.Field));
+																				mc.ManyToOne<Related>("ManyToOne", y => y.Access(Accessor.Field));
+																				mc.Any<object>("Any", typeof(int), y => y.Access(Accessor.Field));
+																				mc.Component("DynamicCompo", new { A = 2 }, y => y.Access(Accessor.Field));
+																				mc.Component<MyCompo>("Compo", y =>
+			                                 	                           {
+			                                 	                           	y.Access(Accessor.Field);
+			                                 	                           	y.Property(c => c.Something);
+			                                 	                           });
+			                                 });
+			var mappings = mapper.CompileMappingForAllExplicitAddedEntities();
+			var hbmClass = mappings.RootClasses[0];
+			var hbmJoinedSubclass = mappings.JoinedSubclasses[0];
+			hbmClass.Properties.Select(p => p.Name).Should().Have.SameValuesAs("Simple", "ComplexType", "Bag", "IdBag", "List", "Set", "Map", "Compo", "OneToOne", "ManyToOne", "Any", "DynamicCompo");
+			hbmClass.Properties.Select(p => p.Access).All(x => x.Satisfy(access => access.Contains("field.")));
+			hbmJoinedSubclass.Properties.Should().Be.Empty();
+		}
+
+		[Test]
+		public void WhenMapPropertiesInTheBaseJumpedClassUsingMemberNameThenMapInInherited()
+		{
+			// ignoring MyClass and using Inherited, as root-class, I will try to map all properties using the base class.
+			// NH have to recognize the case and map those properties in the inherited.
+			var inspector = new SimpleModelInspector();
+			inspector.IsRootEntity((type, declared) => type == typeof (Inherited));
+			var mapper = new ModelMapper();
+			mapper.Class<MyClass>(mc =>
+			                      {
+			                      	mc.Id(x => x.Id);
+			                      	mc.Property("Simple", map => map.Access(Accessor.Field));
+			                      	mc.Property("ComplexType", map => map.Access(Accessor.Field));
+			                      	mc.Bag<string>("Bag", y => y.Access(Accessor.Field));
+			                      	mc.IdBag<MyCompo>("IdBag", y => y.Access(Accessor.Field));
+			                      	mc.List<string>("List", y => y.Access(Accessor.Field));
+			                      	mc.Set<string>("Set", y => y.Access(Accessor.Field));
+			                      	mc.Map<int, string>("Map", y => y.Access(Accessor.Field));
+			                      	mc.OneToOne<Related>("OneToOne", y => y.Access(Accessor.Field));
+			                      	mc.ManyToOne<Related>("ManyToOne", y => y.Access(Accessor.Field));
+			                      	mc.Any<object>("Any", typeof (int), y => y.Access(Accessor.Field));
+			                      	mc.Component("DynamicCompo", new {A = 2}, y => y.Access(Accessor.Field));
+			                      	mc.Component<MyCompo>("Compo", y =>
+			                      	                               {
+			                      	                               	y.Access(Accessor.Field);
+			                      	                               	y.Property(c => c.Something);
+			                      	                               });
+			                      });
+			mapper.Class<Inherited>(mc => { });
+
+			HbmMapping mappings = mapper.CompileMappingForAllExplicitAddedEntities();
+			HbmClass hbmClass = mappings.RootClasses[0];
+			mappings.JoinedSubclasses.Should().Be.Empty();
+			hbmClass.Properties.Select(p => p.Name).Should().Have.SameValuesAs("Simple", "ComplexType", "Bag", "IdBag", "List", "Set", "Map", "Compo", "OneToOne", "ManyToOne", "Any",
+			                                                                   "DynamicCompo");
+			hbmClass.Properties.Select(p => p.Access).All(x => x.Satisfy(access => access.Contains("field.")));
+		}
+	}
+}
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-04-29 18:28:17 UTC (rev 5789)
+++ trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-04-29 21:16:22 UTC (rev 5790)
@@ -517,6 +517,7 @@
     <Compile Include="MappingByCode\ConventionModelMapperTests\PropertyToFieldAccessorTest.cs" />
     <Compile Include="MappingByCode\ConventionModelMapperTests\SafePoidTests.cs" />
     <Compile Include="MappingByCode\ConventionModelMapperTests\VersionOnBaseClassIntegrationTest.cs" />
+    <Compile Include="MappingByCode\ExpliticMappingTests\AllPropertiesRegistrationTests.cs" />
     <Compile Include="MappingByCode\ExpliticMappingTests\BagOfNestedComponentsWithParentTest.cs" />
     <Compile Include="MappingByCode\ExpliticMappingTests\ClassWithComponentsTest.cs" />
     <Compile Include="MappingByCode\ExpliticMappingTests\ComponentAsIdTests.cs" />


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5789] trunk/nhibernate/src/NHibernate

[<fab...@us...>]

Revision: 5789
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5789&view=rev
Author:   fabiomaulo
Date:     2011-04-29 18:28:17 +0000 (Fri, 29 Apr 2011)

Log Message:
-----------
by-code : Breaking change with Alpha2 to map private/protected members

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/IPlainPropertyContainerMapper.cs
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/JoinCustomizer.cs
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/NaturalIdCustomizer.cs
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/PropertyContainerCustomizer.cs
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/ConventionModelMapperTests/PropertyToFieldAccessorTest.cs
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/MappingOfPrivateMembersOnRootEntity.cs
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/MixAutomapping/PropertiesExclusionTests.cs

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/IPlainPropertyContainerMapper.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/IPlainPropertyContainerMapper.cs	2011-04-29 16:51:56 UTC (rev 5788)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/IPlainPropertyContainerMapper.cs	2011-04-29 18:28:17 UTC (rev 5789)
@@ -28,7 +28,7 @@
 	{
 		void Property<TProperty>(Expression<Func<TContainer, TProperty>> property);
 		void Property<TProperty>(Expression<Func<TContainer, TProperty>> property, Action<IPropertyMapper> mapping);
-		void Property(FieldInfo member, Action<IPropertyMapper> mapping);
+		void Property(string notVidiblePropertyOrFieldName, Action<IPropertyMapper> mapping);
 
 		void ManyToOne<TProperty>(Expression<Func<TContainer, TProperty>> property, Action<IManyToOneMapper> mapping) where TProperty : class;
 		void ManyToOne<TProperty>(Expression<Func<TContainer, TProperty>> property) where TProperty : class;

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/JoinCustomizer.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/JoinCustomizer.cs	2011-04-29 16:51:56 UTC (rev 5788)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/JoinCustomizer.cs	2011-04-29 18:28:17 UTC (rev 5789)
@@ -117,10 +117,12 @@
 			base.RegisterPropertyMapping(property, mapping);
 		}
 
-		protected override void RegisterFieldMapping(FieldInfo member, Action<IPropertyMapper> mapping)
+		protected override void RegisterNoVisiblePropertyMapping(string notVidiblePropertyOrFieldName, System.Action<IPropertyMapper> mapping)
 		{
+			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+
 			ExplicitDeclarationsHolder.AddAsPropertySplit(new SplitDefinition(typeof(TEntity), splitGroupId, member));
-			base.RegisterFieldMapping(member, mapping);
+			base.RegisterNoVisiblePropertyMapping(notVidiblePropertyOrFieldName, mapping);
 		}
 
 		protected override void RegisterComponentMapping<TComponent>(Expression<Func<TEntity, TComponent>> property, Action<IComponentMapper<TComponent>> mapping)

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/NaturalIdCustomizer.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/NaturalIdCustomizer.cs	2011-04-29 16:51:56 UTC (rev 5788)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/NaturalIdCustomizer.cs	2011-04-29 18:28:17 UTC (rev 5789)
@@ -16,10 +16,14 @@
 			base.RegisterPropertyMapping(property, mapping);
 		}
 
-		protected override void RegisterFieldMapping(FieldInfo member, System.Action<IPropertyMapper> mapping)
+		protected override void RegisterNoVisiblePropertyMapping(string notVidiblePropertyOrFieldName, System.Action<IPropertyMapper> mapping)
 		{
+			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
+
 			ExplicitDeclarationsHolder.AddAsNaturalId(member);
-			base.RegisterFieldMapping(member, mapping);
+			ExplicitDeclarationsHolder.AddAsNaturalId(memberOf);
+			base.RegisterNoVisiblePropertyMapping(notVidiblePropertyOrFieldName, mapping);
 		}
 
 		protected override void RegisterComponentMapping<TComponent>(System.Linq.Expressions.Expression<System.Func<TEntity, TComponent>> property, System.Action<IComponentMapper<TComponent>> mapping)

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/PropertyContainerCustomizer.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/PropertyContainerCustomizer.cs	2011-04-29 16:51:56 UTC (rev 5788)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/PropertyContainerCustomizer.cs	2011-04-29 18:28:17 UTC (rev 5789)
@@ -49,15 +49,21 @@
 			explicitDeclarationsHolder.AddAsProperty(memberOf);
 		}
 
-		public void Property(FieldInfo member, Action<IPropertyMapper> mapping)
+		public void Property(string notVidiblePropertyOrFieldName, Action<IPropertyMapper> mapping)
 		{
-			RegisterFieldMapping(member, mapping);
+			RegisterNoVisiblePropertyMapping(notVidiblePropertyOrFieldName, mapping);
 		}
 
-		protected virtual void RegisterFieldMapping(FieldInfo member, Action<IPropertyMapper> mapping)
+		protected virtual void RegisterNoVisiblePropertyMapping(string notVidiblePropertyOrFieldName, Action<IPropertyMapper> mapping)
 		{
+			// even seems repetitive, before unify this registration with the registration using Expression take in account that reflection operations
+			// done unsing expressions are faster than those done with pure reflection.
+			MemberInfo member = typeof(TEntity).GetPropertyOrFieldMatchingName(notVidiblePropertyOrFieldName);
+			MemberInfo memberOf = member.GetMemberFromReflectedType(typeof(TEntity));
 			CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, member), mapping);
+			CustomizersHolder.AddCustomizer(new PropertyPath(PropertyPath, memberOf), mapping);
 			explicitDeclarationsHolder.AddAsProperty(member);
+			explicitDeclarationsHolder.AddAsProperty(memberOf);
 		}
 
 		public void Component<TComponent>(Expression<Func<TEntity, TComponent>> property,

Modified: trunk/nhibernate/src/NHibernate.Test/MappingByCode/ConventionModelMapperTests/PropertyToFieldAccessorTest.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/ConventionModelMapperTests/PropertyToFieldAccessorTest.cs	2011-04-29 16:51:56 UTC (rev 5788)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/ConventionModelMapperTests/PropertyToFieldAccessorTest.cs	2011-04-29 18:28:17 UTC (rev 5789)
@@ -50,9 +50,8 @@
 		[Test]
 		public void WhenFieldAccessToField()
 		{
-			var member = typeof(MyClass).GetField("aField",BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
 			var mapper = new ConventionModelMapper();
-			mapper.Class<MyClass>(mc => mc.Property(member, x => { }));
+			mapper.Class<MyClass>(mc => mc.Property("aField", x => { }));
 			var hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClass) });
 
 			var hbmClass = hbmMapping.RootClasses[0];

Modified: trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/MappingOfPrivateMembersOnRootEntity.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/MappingOfPrivateMembersOnRootEntity.cs	2011-04-29 16:51:56 UTC (rev 5788)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExpliticMappingTests/MappingOfPrivateMembersOnRootEntity.cs	2011-04-29 18:28:17 UTC (rev 5789)
@@ -25,7 +25,7 @@
 					map.Column("MyClassId");
 					map.Generator(Generators.HighLow, gmap => gmap.Params(new { max_low = 100 }));
 				});
-				ca.Property(ForClass<MyClass>.Field("something"), map => map.Length(150));
+				ca.Property("something", map => map.Length(150));
 			});
 			var hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClass) });
 			var hbmClass = hbmMapping.RootClasses[0];

Modified: trunk/nhibernate/src/NHibernate.Test/MappingByCode/MixAutomapping/PropertiesExclusionTests.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/MixAutomapping/PropertiesExclusionTests.cs	2011-04-29 16:51:56 UTC (rev 5788)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/MixAutomapping/PropertiesExclusionTests.cs	2011-04-29 18:28:17 UTC (rev 5789)
@@ -84,7 +84,7 @@
 		{
 			var autoinspector = new SimpleModelInspector();
 			var mapper = new ModelMapper(autoinspector);
-			mapper.Class<MyEntity>(map => map.Property(ForClass<MyEntity>.Field("pizza"), x => { }));
+			mapper.Class<MyEntity>(map => map.Property("pizza", x => { }));
 			var inspector = (IModelInspector)autoinspector;
 
 			var pi = typeof(MyEntity).GetField("pizza", BindingFlags.Instance | BindingFlags.NonPublic);


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5788] trunk/nhibernate/src/NHibernate

[<fab...@us...>]

Revision: 5788
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5788&view=rev
Author:   fabiomaulo
Date:     2011-04-29 16:51:56 +0000 (Fri, 29 Apr 2011)

Log Message:
-----------
SimpleModelInspector managing polymorphic registration

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/SimpleModelInspector.cs
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/TypeExtensions.cs
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/TypeExtensionsTest.cs
    trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj

Added Paths:
-----------
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/MixAutomapping/PolymorphicPropertiesMapping.cs

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/SimpleModelInspector.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/SimpleModelInspector.cs	2011-04-28 22:49:42 UTC (rev 5787)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/SimpleModelInspector.cs	2011-04-29 16:51:56 UTC (rev 5788)
@@ -530,108 +530,108 @@
 
 		bool IModelInspector.IsOneToOne(MemberInfo member)
 		{
-			bool declaredResult = declaredModel.IsOneToOne(member);
+			bool declaredResult = DeclaredPolymorphicMatch(member, m => declaredModel.IsOneToOne(m));
 			return isOneToOne(member, declaredResult);
 		}
 
 		bool IModelInspector.IsManyToOne(MemberInfo member)
 		{
-			bool declaredResult = declaredModel.IsManyToOne(member);
+			bool declaredResult = DeclaredPolymorphicMatch(member, m => declaredModel.IsManyToOne(m));
 			return isManyToOne(member, declaredResult);
 		}
 
 		bool IModelInspector.IsManyToMany(MemberInfo member)
 		{
-			bool declaredResult = declaredModel.IsManyToMany(member);
+			bool declaredResult = DeclaredPolymorphicMatch(member, m => declaredModel.IsManyToMany(m));
 			return isManyToMany(member, declaredResult);
 		}
 
 		bool IModelInspector.IsOneToMany(MemberInfo member)
 		{
-			bool declaredResult = declaredModel.IsOneToMany(member);
+			bool declaredResult = DeclaredPolymorphicMatch(member, m => declaredModel.IsOneToMany(m));
 			return isOneToMany(member, declaredResult);
 		}
 
 		bool IModelInspector.IsAny(MemberInfo member)
 		{
-			bool declaredResult = declaredModel.IsAny(member);
+			bool declaredResult = DeclaredPolymorphicMatch(member, m => declaredModel.IsAny(m));
 			return isAny(member, declaredResult);
 		}
 
 		bool IModelInspector.IsPersistentId(MemberInfo member)
 		{
-			bool declaredResult = declaredModel.IsPersistentId(member);
+			bool declaredResult = DeclaredPolymorphicMatch(member, m => declaredModel.IsPersistentId(m));
 			return isPersistentId(member, declaredResult);
 		}
 
 		bool IModelInspector.IsMemberOfComposedId(MemberInfo member)
 		{
-			return declaredModel.IsPersistentId(member);
+			return declaredModel.IsMemberOfComposedId(member);
 		}
 
 		bool IModelInspector.IsVersion(MemberInfo member)
 		{
-			bool declaredResult = declaredModel.IsVersion(member);
+			bool declaredResult = DeclaredPolymorphicMatch(member, m => declaredModel.IsVersion(m));
 			return isVersion(member, declaredResult);
 		}
 
 		bool IModelInspector.IsMemberOfNaturalId(MemberInfo member)
 		{
-			bool declaredResult = declaredModel.IsMemberOfNaturalId(member);
+			bool declaredResult = DeclaredPolymorphicMatch(member, m => declaredModel.IsMemberOfNaturalId(m));
 			return isMemberOfNaturalId(member, declaredResult);
 		}
 
 		bool IModelInspector.IsPersistentProperty(MemberInfo member)
 		{
-			bool declaredResult = declaredModel.IsPersistentProperty(member);
+			bool declaredResult = DeclaredPolymorphicMatch(member, m => declaredModel.IsPersistentProperty(m));
 			return isPersistentProperty(member, declaredResult);
 		}
 
 		bool IModelInspector.IsSet(MemberInfo role)
 		{
-			bool declaredResult = declaredModel.IsSet(role);
+			bool declaredResult = DeclaredPolymorphicMatch(role, m => declaredModel.IsSet(m));
 			return isSet(role, declaredResult);
 		}
 
 		bool IModelInspector.IsBag(MemberInfo role)
 		{
-			bool declaredResult = declaredModel.IsBag(role);
+			bool declaredResult = DeclaredPolymorphicMatch(role, m => declaredModel.IsBag(m));
 			return isBag(role, declaredResult);
 		}
 
 		bool IModelInspector.IsIdBag(MemberInfo role)
 		{
-			bool declaredResult = declaredModel.IsIdBag(role);
+			bool declaredResult = DeclaredPolymorphicMatch(role, m => declaredModel.IsIdBag(m));
 			return isIdBag(role, declaredResult);
 		}
 
 		bool IModelInspector.IsList(MemberInfo role)
 		{
-			bool declaredResult = declaredModel.IsList(role);
+			bool declaredResult = DeclaredPolymorphicMatch(role, m => declaredModel.IsList(m));
 			return isList(role, declaredResult);
 		}
 
 		bool IModelInspector.IsArray(MemberInfo role)
 		{
-			bool declaredResult = declaredModel.IsArray(role);
+			bool declaredResult = DeclaredPolymorphicMatch(role, m => declaredModel.IsArray(m));
 			return isArray(role, declaredResult);
 		}
 
 		bool IModelInspector.IsDictionary(MemberInfo role)
 		{
-			bool declaredResult = declaredModel.IsDictionary(role);
+			bool declaredResult = DeclaredPolymorphicMatch(role, m => declaredModel.IsDictionary(m));
 			return isDictionary(role, declaredResult);
 		}
 
 		bool IModelInspector.IsProperty(MemberInfo member)
 		{
-			bool declaredResult = declaredModel.IsProperty(member);
+			bool declaredResult = DeclaredPolymorphicMatch(member, m => declaredModel.IsProperty(m));
 			return isProperty(member, declaredResult);
 		}
 
 		bool IModelInspector.IsDynamicComponent(MemberInfo member)
 		{
-			bool declaredResult = declaredModel.IsDynamicComponent(member);
+			bool declaredResult = DeclaredPolymorphicMatch(member, m => declaredModel.IsDynamicComponent(m));
 			return isDynamicComponent(member, declaredResult);
 		}
 
@@ -652,6 +652,13 @@
 
 		#endregion
 
+		protected virtual bool DeclaredPolymorphicMatch(MemberInfo member, Func<MemberInfo, bool> declaredMatch)
+		{
+			return declaredMatch(member)
+						 || member.GetMemberFromDeclaringClasses().Any(declaredMatch)
+						 || member.GetPropertyFromInterfaces().Any(declaredMatch);
+		}
+
 		public void IsRootEntity(Func<System.Type, bool, bool> match)
 		{
 			if (match == null)

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/TypeExtensions.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/TypeExtensions.cs	2011-04-28 22:49:42 UTC (rev 5787)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/TypeExtensions.cs	2011-04-29 16:51:56 UTC (rev 5788)
@@ -170,9 +170,36 @@
 			{
 				return source;
 			}
-			return source.DeclaringType.GetProperty(source.Name, BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
+			if (source is PropertyInfo)
+			{
+				return source.DeclaringType.GetProperty(source.Name, BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
+			}
+			if (source is FieldInfo)
+			{
+				return source.DeclaringType.GetField(source.Name, BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
+			}
+			return null;
 		}
 
+		public static IEnumerable<MemberInfo> GetMemberFromDeclaringClasses(this MemberInfo source)
+		{
+			if (source == null)
+			{
+				throw new ArgumentNullException("source");
+			}
+			if (source is PropertyInfo)
+			{
+				var reflectedType = source.ReflectedType;
+				var memberType = source.GetPropertyOrFieldType();
+				return reflectedType.GetPropertiesOfHierarchy().Cast<PropertyInfo>().Where(x => source.Name.Equals(x.Name) && memberType.Equals(x.PropertyType)).Cast<MemberInfo>();
+			}
+			if (source is FieldInfo)
+			{
+				return new[] { source.GetMemberFromDeclaringType() };
+			}
+			return Enumerable.Empty<MemberInfo>();
+		}
+
 		public static IEnumerable<MemberInfo> GetPropertyFromInterfaces(this MemberInfo source)
 		{
 			if (source == null)

Added: trunk/nhibernate/src/NHibernate.Test/MappingByCode/MixAutomapping/PolymorphicPropertiesMapping.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/MixAutomapping/PolymorphicPropertiesMapping.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/MixAutomapping/PolymorphicPropertiesMapping.cs	2011-04-29 16:51:56 UTC (rev 5788)
@@ -0,0 +1,99 @@
+using System;
+using System.Reflection;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+using SharpTestsEx;
+
+namespace NHibernate.Test.MappingByCode.MixAutomapping
+{
+	public class PolymorphicPropertiesMapping
+	{
+		const BindingFlags RootClassPropertiesBindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy;
+	
+		private interface IBaseEntity
+		{
+			int Id { get; }
+		}
+
+		private class BaseEntity : IBaseEntity
+		{
+			public int Id { get; protected set; }
+			public DateTime LastChange { get { return DateTime.Now; } }
+		}
+
+		private interface IProduct : IBaseEntity
+		{
+			string Description { get;}
+		}
+
+		private abstract class BaseProduct : BaseEntity, IProduct
+		{
+			public abstract string Description { get;  }
+		}
+
+		private class Product : BaseProduct
+		{
+			public override string Description
+			{
+				get { return "blah"; }
+			}
+		}
+
+		[Test]
+		public void WhenMapIdThroughBaseInterfaceThenFindIt()
+		{
+			var inspector = (IModelInspector)new SimpleModelInspector();
+			var mapper = new ModelMapper(inspector);
+			mapper.Class<IBaseEntity>(
+				map =>
+				{
+					map.Id(x => x.Id, idmap => { });
+				});
+			inspector.IsPersistentId(typeof(Product).GetProperty("Id", RootClassPropertiesBindingFlags)).Should().Be.True();
+		}
+
+		[Test]
+		public void WhenMapPropertyThroughBaseConcreteClassThenFindIt()
+		{
+			var inspector = (IModelInspector)new SimpleModelInspector();
+			var mapper = new ModelMapper(inspector);
+
+			mapper.Class<BaseEntity>(map => map.Property(x => x.LastChange));
+
+			inspector.IsPersistentProperty(typeof(Product).GetProperty("LastChange", RootClassPropertiesBindingFlags)).Should().Be.True();
+		}
+
+		[Test]
+		public void WhenMapPropertyThroughBaseInterfaceThenFindIt()
+		{
+			var inspector = (IModelInspector)new SimpleModelInspector();
+			var mapper = new ModelMapper(inspector);
+
+			mapper.Class<IProduct>(map => map.Property(x => x.Description));
+
+			inspector.IsPersistentProperty(typeof(Product).GetProperty("Description", RootClassPropertiesBindingFlags)).Should().Be.True();
+		}
+
+		[Test]
+		public void WhenMapPropertyThroughBaseAbstractClassThenFindIt()
+		{
+			var inspector = (IModelInspector)new SimpleModelInspector();
+			var mapper = new ModelMapper(inspector);
+
+			mapper.Class<BaseProduct>(map => map.Property(x => x.Description));
+
+			inspector.IsPersistentProperty(typeof(Product).GetProperty("Description", RootClassPropertiesBindingFlags)).Should().Be.True();
+		}
+
+		[Test]
+		public void WhenMapPropertyThroughClassThenFindIt()
+		{
+			var inspector = (IModelInspector)new SimpleModelInspector();
+			var mapper = new ModelMapper(inspector);
+
+			mapper.Class<Product>(map => map.Property(x => x.Description));
+
+			inspector.IsPersistentProperty(typeof(Product).GetProperty("Description", RootClassPropertiesBindingFlags)).Should().Be.True();
+		}
+	}
+}
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/TypeExtensionsTest.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/TypeExtensionsTest.cs	2011-04-28 22:49:42 UTC (rev 5787)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/TypeExtensionsTest.cs	2011-04-29 16:51:56 UTC (rev 5788)
@@ -2,6 +2,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Linq;
 using System.Reflection;
 using NHibernate.Mapping.ByCode;
 using NUnit.Framework;
@@ -203,5 +204,41 @@
 			typeof(MyBaseClass).HasPublicPropertyOf(typeof(string), x => false).Should().Be.False();
 			typeof(MyBaseClass).HasPublicPropertyOf(typeof(string), x => true).Should().Be.True();
 		}
+
+		private abstract class MyAbstract
+		{
+			protected int aField;
+			public abstract string Description { get; }
+		}
+
+		private class MyConcrete : MyAbstract
+		{
+			public override string Description
+			{
+				get { return "blah"; }
+			}
+		}
+
+		[Test]
+		public void GetMemberFromDeclaringClasses_WhenPropertyThenFindAbstract()
+		{
+			var member = typeof(MyConcrete).GetProperty("Description", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
+			var found = member.GetMemberFromDeclaringClasses().ToList();
+			found.Count.Should().Be(2);
+			var concreteMember = For<MyConcrete>.Property(x => x.Description).GetMemberFromReflectedType(typeof(MyConcrete));
+			var abstractMember = For<MyAbstract>.Property(x => x.Description);
+			found.Should().Have.SameValuesAs(concreteMember, abstractMember);
+		}
+
+		[Test]
+		public void GetMemberFromDeclaringClasses_WhenFieldThenFindAbstract()
+		{
+			var member = typeof(MyConcrete).GetField("aField", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
+			var found = member.GetMemberFromDeclaringClasses().ToList();
+			found.Count.Should().Be(1);
+			var foundMember = found.Single();
+			foundMember.DeclaringType.Should().Be(typeof(MyAbstract));
+			foundMember.ReflectedType.Should().Be(typeof(MyAbstract));
+		}
 	}
 }
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-04-28 22:49:42 UTC (rev 5787)
+++ trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-04-29 16:51:56 UTC (rev 5788)
@@ -592,6 +592,7 @@
     <Compile Include="MappingByCode\MixAutomapping\ManyToOneTest.cs" />
     <Compile Include="MappingByCode\MixAutomapping\OneToManyTests.cs" />
     <Compile Include="MappingByCode\MixAutomapping\PoidTests.cs" />
+    <Compile Include="MappingByCode\MixAutomapping\PolymorphicPropertiesMapping.cs" />
     <Compile Include="MappingByCode\MixAutomapping\PropertiesExclusionTests.cs" />
     <Compile Include="MappingByCode\MixAutomapping\RootEntityTests.cs" />
     <Compile Include="MappingByCode\MixAutomapping\SetCollectionTests.cs" />


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5787] trunk/nhibernate/src/NHibernate

[<fab...@us...>]

Revision: 5787
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5787&view=rev
Author:   fabiomaulo
Date:     2011-04-28 22:49:42 +0000 (Thu, 28 Apr 2011)

Log Message:
-----------
GetMemberFromReflectedType implemented

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/TypeExtensions.cs
    trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj

Added Paths:
-----------
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetMemberFromReflectedTest.cs

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/TypeExtensions.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/TypeExtensions.cs	2011-04-28 18:47:30 UTC (rev 5786)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/TypeExtensions.cs	2011-04-28 22:49:42 UTC (rev 5787)
@@ -420,6 +420,61 @@
 		}
 
 		/// <summary>
+		/// Given a property or a field try to get the member from a given possible inherited type.
+		/// </summary>
+		/// <param name="member">The member to find.</param>
+		/// <param name="reflectedType">The type where find the member.</param>
+		/// <returns>The member from the reflected-type or the original <paramref name="member"/> where the <paramref name="member"/> is not accessible from <paramref name="reflectedType"/>.</returns>
+		public static MemberInfo GetMemberFromReflectedType(this MemberInfo member, System.Type reflectedType)
+		{
+			if (member == null)
+			{
+				throw new ArgumentNullException("member");
+			}
+			if (reflectedType == null)
+			{
+				throw new ArgumentNullException("reflectedType");
+			}
+			var field = member as FieldInfo;
+			if (field != null && field.IsPrivate)
+			{
+				return member;
+			}
+			var property = member as PropertyInfo;
+			if (property != null)
+			{
+				var propertyGetter = property.GetGetMethod(true);
+				if (propertyGetter.IsPrivate)
+				{
+					return member;
+				}
+				if (property.DeclaringType.IsInterface)
+				{
+					System.Type[] interfaces = reflectedType.GetInterfaces();
+					var @interface = property.DeclaringType;
+					if (!interfaces.Contains(@interface))
+					{
+						return member;
+					}
+					var reflectedCandidateProps = reflectedType.GetProperties(PropertiesOfClassHierarchy);
+					InterfaceMapping memberMap = reflectedType.GetInterfaceMap(@interface);
+					for (int i = 0; i < memberMap.TargetMethods.Length; i++)
+					{
+						if (memberMap.InterfaceMethods[i] == propertyGetter)
+						{
+							return reflectedCandidateProps.Single(pi => pi.GetGetMethod(true) == memberMap.TargetMethods[i]);
+						}
+					}
+					return member;
+				}
+			}
+			var reflectedTypeProperties = reflectedType.GetProperties(PropertiesOfClassHierarchy);
+			var members = reflectedTypeProperties.Cast<MemberInfo>().Concat(reflectedType.GetFields(PropertiesOfClassHierarchy));
+			var result = members.FirstOrDefault(m=> m.Name.Equals(member.Name) && m.GetPropertyOrFieldType().Equals(member.GetPropertyOrFieldType()));
+			return result ?? member;
+		}
+
+		/// <summary>
 		/// Try to find a property or field from a given type.
 		/// </summary>
 		/// <param name="source">The type</param>

Added: trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetMemberFromReflectedTest.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetMemberFromReflectedTest.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetMemberFromReflectedTest.cs	2011-04-28 22:49:42 UTC (rev 5787)
@@ -0,0 +1,133 @@
+using System;
+using System.Reflection;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+using SharpTestsEx;
+
+namespace NHibernate.Test.MappingByCode.TypeExtensionsTests
+{
+	public class GetMemberFromReflectedTest
+	{
+		private const BindingFlags PrivateMembersFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly;
+
+		private class MyClass
+		{
+			private int pField;
+			private int PrivateProperty { get; set; }
+			public int AnotherProperty { get; set; }
+			protected int ProtectedProperty { get; set; }
+			private int Method() { return 0; }
+		}
+
+		private class Inherited : MyClass
+		{
+			private int pField;
+			private int PrivateProperty { get; set; }
+		}
+
+		private interface IInterface
+		{
+			int Something { get; set; }
+			int SomethingElse { get; set; }
+		}
+
+		private class MyClassWithExplicitImpl : IInterface
+		{
+			int IInterface.Something
+			{
+				get
+				{
+					throw new System.NotImplementedException();
+				}
+				set
+				{
+					throw new System.NotImplementedException();
+				}
+			}
+
+			public int SomethingElse
+			{
+				get { throw new NotImplementedException(); }
+				set { throw new NotImplementedException(); }
+			}
+		}
+
+		[Test]
+		public void WhenNullMemberThenThrows()
+		{
+			Executing.This(() => ((MemberInfo)null).GetMemberFromReflectedType(typeof(MyClass))).Should().Throw<ArgumentNullException>();
+		}
+
+		[Test]
+		public void WhenNullTypeThenThrows()
+		{
+			Executing.This(() => typeof(MyClassWithExplicitImpl).GetProperty("SomethingElse").GetMemberFromReflectedType(null)).Should().Throw<ArgumentNullException>();
+		}
+
+		[Test]
+		public void WhenNotExistentThenOriginal()
+		{
+			var propertyInfo = typeof(MyClassWithExplicitImpl).GetProperty("SomethingElse");
+			propertyInfo.GetMemberFromReflectedType(typeof(object)).Should().Be(propertyInfo);
+		}
+
+		[Test]
+		public void WhenNotAccessibleFieldThenOriginal()
+		{
+			var memberInfo = typeof(MyClass).GetField("pField", PrivateMembersFlags);
+			memberInfo.GetMemberFromReflectedType(typeof(Inherited)).Should().Be(memberInfo);
+		}
+
+		[Test]
+		public void WhenNotAccessiblePropertyThenOriginal()
+		{
+			var memberInfo = typeof(MyClass).GetProperty("PrivateProperty", PrivateMembersFlags);
+			memberInfo.GetMemberFromReflectedType(typeof(Inherited)).Should().Be(memberInfo);
+		}
+
+		[Test]
+		public void WhenAccessiblePropertyThenReflected()
+		{
+			var memberInfo = typeof(MyClass).GetProperty("ProtectedProperty", PrivateMembersFlags);
+			var result = memberInfo.GetMemberFromReflectedType(typeof(Inherited));
+			result.ReflectedType.Should().Be(typeof(Inherited));
+			result.DeclaringType.Should().Be(typeof(MyClass));
+		}
+
+		[Test]
+		public void WhenPrivateFieldOnInheritedThenFindItOnInherited()
+		{
+			var memberInfo = typeof(Inherited).GetField("pField", PrivateMembersFlags);
+			var result = memberInfo.GetMemberFromReflectedType(typeof(MyClass));
+			result.ReflectedType.Should().Be(typeof(Inherited));
+			result.DeclaringType.Should().Be(typeof(Inherited));
+		}
+
+		[Test]
+		public void WhenPublicPropertyOfBaseOnInheritedThenFindItOnInherited()
+		{
+			var memberInfo = typeof(MyClass).GetProperty("AnotherProperty");
+			var result = memberInfo.GetMemberFromReflectedType(typeof(Inherited));
+			result.ReflectedType.Should().Be(typeof(Inherited));
+			result.DeclaringType.Should().Be(typeof(MyClass));
+		}
+
+		[Test]
+		public void WhenPropertyOfInterfaceThenFindItOnClass()
+		{
+			var memberInfo = typeof(IInterface).GetProperty("SomethingElse");
+			var result = memberInfo.GetMemberFromReflectedType(typeof(MyClassWithExplicitImpl));
+			result.DeclaringType.Should().Be(typeof(MyClassWithExplicitImpl));
+			result.ReflectedType.Should().Be(typeof(MyClassWithExplicitImpl));
+		}
+
+		[Test]
+		public void WhenPropertyOfExplicitInterfaceThenFindItOnClass()
+		{
+			var memberInfo = typeof(IInterface).GetProperty("Something");
+			var result = memberInfo.GetMemberFromReflectedType(typeof(MyClassWithExplicitImpl));
+			result.DeclaringType.Should().Be(typeof(MyClassWithExplicitImpl));
+			result.ReflectedType.Should().Be(typeof(MyClassWithExplicitImpl));
+		}
+	}
+}
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-04-28 18:47:30 UTC (rev 5786)
+++ trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-04-28 22:49:42 UTC (rev 5787)
@@ -612,6 +612,7 @@
     <Compile Include="MappingByCode\TypeExtensionsTests\GetFirstImplementorConcreteClassesTest.cs" />
     <Compile Include="MappingByCode\TypeExtensionsTests\GetFirstImplementorTest.cs" />
     <Compile Include="MappingByCode\TypeExtensionsTests\GetMemberFromInterfacesTest.cs" />
+    <Compile Include="MappingByCode\TypeExtensionsTests\GetMemberFromReflectedTest.cs" />
     <Compile Include="MappingByCode\TypeExtensionsTests\GetPropertyOrFieldMatchingNameTest.cs" />
     <Compile Include="MappingByCode\TypeExtensionsTests\TypeExtensionsTest.cs" />
     <Compile Include="MappingByCode\TypeNameUtilTests.cs" />


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5786] trunk/nhibernate/src/NHibernate

[<fab...@us...>]

Revision: 5786
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5786&view=rev
Author:   fabiomaulo
Date:     2011-04-28 18:47:30 +0000 (Thu, 28 Apr 2011)

Log Message:
-----------
by-code: Preparing to add new API for private/protected properties/fields

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/TypeExtensions.cs
    trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj

Added Paths:
-----------
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetPropertyOrFieldMatchingNameTest.cs

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/TypeExtensions.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/TypeExtensions.cs	2011-04-28 12:43:58 UTC (rev 5785)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/TypeExtensions.cs	2011-04-28 18:47:30 UTC (rev 5786)
@@ -9,8 +9,9 @@
 {
 	public static class TypeExtensions
 	{
-		private const BindingFlags PublicPropertiesOfClassHierarchy =
+		private const BindingFlags PropertiesOfClassHierarchy =
 			BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy;
+		private const BindingFlags PropertiesOrFieldOfClass = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly;
 
 		public static IEnumerable<System.Type> GetBaseTypes(this System.Type type)
 		{
@@ -410,12 +411,97 @@
 
 		public static bool HasPublicPropertyOf(this System.Type source, System.Type typeOfProperty)
 		{
-			return GetFirstPropertyOfType(source, typeOfProperty, PublicPropertiesOfClassHierarchy) != null;
+			return GetFirstPropertyOfType(source, typeOfProperty, PropertiesOfClassHierarchy) != null;
 		}
 
 		public static bool HasPublicPropertyOf(this System.Type source, System.Type typeOfProperty, Func<PropertyInfo, bool> acceptPropertyClauses)
 		{
-			return GetFirstPropertyOfType(source, typeOfProperty, PublicPropertiesOfClassHierarchy, acceptPropertyClauses) != null;
+			return GetFirstPropertyOfType(source, typeOfProperty, PropertiesOfClassHierarchy, acceptPropertyClauses) != null;
 		}
+
+		/// <summary>
+		/// Try to find a property or field from a given type.
+		/// </summary>
+		/// <param name="source">The type</param>
+		/// <param name="memberName">The property or field name.</param>
+		/// <returns>
+		/// A <see cref="PropertyInfo"/> or a <see cref="FieldInfo"/> where the member is found; null otherwise.
+		/// </returns>
+		/// <remarks>
+		/// Where found the member is returned always from the declaring type.
+		/// </remarks>
+		public static MemberInfo GetPropertyOrFieldMatchingName(this System.Type source, string memberName)
+		{
+			if (source == null)
+			{
+				throw new ArgumentNullException("source");
+			}
+			if (memberName == null)
+			{
+				return null;
+			}
+			var nameToFind = memberName.Trim();
+			var members = source.GetPropertiesOfHierarchy().Concat(source.GetFieldsOfHierarchy()).Concat(source.GetPropertiesOfInterfacesImplemented());
+			return members.FirstOrDefault(x => x.Name == nameToFind);
+		}
+
+		private static IEnumerable<MemberInfo> GetPropertiesOfInterfacesImplemented(this System.Type source)
+		{
+			if (source.IsInterface)
+			{
+				foreach (var interfaceProperty in source.GetInterfaceProperties())
+				{
+					yield return interfaceProperty;
+				}
+				yield break;
+			}
+			foreach (var @interface in source.GetInterfaces())
+			{
+				foreach (var interfaceProperty in @interface.GetInterfaceProperties())
+				{
+					yield return interfaceProperty;
+				}
+			}
+		}
+
+		private static IEnumerable<MemberInfo> GetPropertiesOfHierarchy(this System.Type type)
+		{
+			if(type.IsInterface)
+			{
+				yield break;
+			}
+			System.Type analizing = type;
+			while (analizing != null && analizing != typeof(object))
+			{
+				foreach (PropertyInfo propertyInfo in analizing.GetProperties(PropertiesOrFieldOfClass))
+				{
+					yield return propertyInfo;
+				}
+				analizing = analizing.BaseType;
+			}
+		}
+
+		private static IEnumerable<MemberInfo> GetFieldsOfHierarchy(this System.Type type)
+		{
+			if (type.IsInterface)
+			{
+				yield break;
+			}
+			System.Type analizing = type;
+			while (analizing != null && analizing != typeof(object))
+			{
+				foreach (FieldInfo fieldInfo in GetUserDeclaredFields(analizing))
+				{
+					yield return fieldInfo;
+				}
+				analizing = analizing.BaseType;
+			}
+		}
+
+		private static IEnumerable<FieldInfo> GetUserDeclaredFields(System.Type type)
+		{
+			// can't find another way to exclude fields generated by the compiler (for both auto-properties and anonymous-types)
+			return type.GetFields(PropertiesOrFieldOfClass).Where(x => !x.Name.StartsWith("<"));
+		}
 	}
 }
\ No newline at end of file

Added: trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetPropertyOrFieldMatchingNameTest.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetPropertyOrFieldMatchingNameTest.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetPropertyOrFieldMatchingNameTest.cs	2011-04-28 18:47:30 UTC (rev 5786)
@@ -0,0 +1,178 @@
+using System;
+using System.Reflection;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+using SharpTestsEx;
+namespace NHibernate.Test.MappingByCode.TypeExtensionsTests
+{
+	public class GetPropertyOrFieldMatchingNameTest
+	{
+		private class MyClass
+		{
+			private int pField;
+			private int PrivateProperty { get; set; }
+			private int AnotherPrivateProperty { get; set; }
+			protected int ProtectedProperty { get; set; }
+			private int Method() { return 0; }
+		}
+
+		private class Inherited: MyClass
+		{
+			private int pField;
+			private int PrivateProperty { get; set; }
+		}
+
+		private interface IInterface
+		{
+			int Something { get; set; }
+			int SomethingElse { get; set; }
+		}
+
+		private class MyClassWithExplicitImpl: IInterface
+		{
+			int IInterface.Something
+			{
+				get
+				{
+					throw new System.NotImplementedException();
+				}
+				set
+				{
+					throw new System.NotImplementedException();
+				}
+			}
+
+			public int SomethingElse
+			{
+				get { throw new NotImplementedException(); }
+				set { throw new NotImplementedException(); }
+			}
+		}
+
+		[Test]
+		public void WhenNullTypeThenThrows()
+		{
+			Executing.This(() => ((System.Type)null).GetPropertyOrFieldMatchingName("A")).Should().Throw<ArgumentNullException>();
+		}
+
+		[Test]
+		public void WhenAskNullThenNull()
+		{
+			typeof(MyClass).GetPropertyOrFieldMatchingName(null).Should().Be.Null();
+		}
+
+		[Test]
+		public void WhenAskNotExistentThenNull()
+		{
+			typeof(MyClass).GetPropertyOrFieldMatchingName("NotExistent").Should().Be.Null();
+		}
+
+		[Test]
+		public void WhenAskPrivateFieldThenFindIt()
+		{
+			var memberInfo = typeof(MyClass).GetPropertyOrFieldMatchingName("pField");
+			memberInfo.Should().Not.Be.Null();
+			memberInfo.Name.Should().Be("pField");
+			memberInfo.Should().Be.InstanceOf<FieldInfo>().And.ValueOf.DeclaringType.Should().Be(typeof(MyClass));
+		}
+
+		[Test]
+		public void WhenAskPrivateFieldWithBlanksThenFindIt()
+		{
+			var memberInfo = typeof(MyClass).GetPropertyOrFieldMatchingName("   pField   ");
+			memberInfo.Should().Not.Be.Null();
+			memberInfo.Name.Should().Be("pField");
+			memberInfo.Should().Be.InstanceOf<FieldInfo>().And.ValueOf.DeclaringType.Should().Be(typeof(MyClass));
+		}
+
+		[Test]
+		public void WhenAskPrivatePropertyThenFindIt()
+		{
+			var memberInfo = typeof(MyClass).GetPropertyOrFieldMatchingName("PrivateProperty");
+			memberInfo.Should().Not.Be.Null();
+			memberInfo.Name.Should().Be("PrivateProperty");
+			memberInfo.Should().Be.InstanceOf<PropertyInfo>().And.ValueOf.DeclaringType.Should().Be(typeof(MyClass));
+		}
+
+		[Test]
+		public void WhenAskProtectedPropertyThenFindIt()
+		{
+			var memberInfo = typeof(MyClass).GetPropertyOrFieldMatchingName("ProtectedProperty");
+			memberInfo.Should().Not.Be.Null();
+			memberInfo.Name.Should().Be("ProtectedProperty");
+			memberInfo.Should().Be.InstanceOf<PropertyInfo>().And.ValueOf.DeclaringType.Should().Be(typeof(MyClass));
+		}
+
+		[Test]
+		public void WhenAskMethodThenNull()
+		{
+			typeof(MyClass).GetPropertyOrFieldMatchingName("Method").Should().Be.Null();
+		}
+
+		[Test]
+		public void WhenAskPrivateFieldOnInheritedThenFindItOnInherited()
+		{
+			var memberInfo = typeof(Inherited).GetPropertyOrFieldMatchingName("pField");
+			memberInfo.Should().Not.Be.Null();
+			memberInfo.Name.Should().Be("pField");
+			memberInfo.DeclaringType.Should().Be(typeof(Inherited));
+			memberInfo.ReflectedType.Should().Be(typeof(Inherited));
+			memberInfo.Should().Be.InstanceOf<FieldInfo>();
+		}
+
+		[Test]
+		public void WhenAskPrivatePropertyOnInheritedThenFindItOnInherited()
+		{
+			var memberInfo = typeof(Inherited).GetPropertyOrFieldMatchingName("PrivateProperty");
+			memberInfo.Should().Not.Be.Null();
+			memberInfo.Name.Should().Be("PrivateProperty");
+			memberInfo.DeclaringType.Should().Be(typeof(Inherited));
+			memberInfo.ReflectedType.Should().Be(typeof(Inherited));
+			memberInfo.Should().Be.InstanceOf<PropertyInfo>();
+		}
+
+		[Test]
+		public void WhenAskPrivatePropertyOfBaseOnInheritedThenFindItOnBase()
+		{
+			var memberInfo = typeof(Inherited).GetPropertyOrFieldMatchingName("AnotherPrivateProperty");
+			memberInfo.Should().Not.Be.Null();
+			memberInfo.Name.Should().Be("AnotherPrivateProperty");
+			memberInfo.DeclaringType.Should().Be(typeof(MyClass));
+			memberInfo.ReflectedType.Should().Be(typeof(MyClass));
+			memberInfo.Should().Be.InstanceOf<PropertyInfo>();
+		}
+
+		[Test]
+		public void WhenAskPropertyOfInterfaceThenFindIt()
+		{
+			var memberInfo = typeof(IInterface).GetPropertyOrFieldMatchingName("Something");
+			memberInfo.Should().Not.Be.Null();
+			memberInfo.Name.Should().Be("Something");
+			memberInfo.DeclaringType.Should().Be(typeof(IInterface));
+			memberInfo.ReflectedType.Should().Be(typeof(IInterface));
+			memberInfo.Should().Be.InstanceOf<PropertyInfo>();
+		}
+
+		[Test]
+		public void WhenAskPropertyOfExplicitInterfaceThenFindItOnInterface()
+		{
+			var memberInfo = typeof(MyClassWithExplicitImpl).GetPropertyOrFieldMatchingName("Something");
+			memberInfo.Should().Not.Be.Null();
+			memberInfo.Name.Should().Be("Something");
+			memberInfo.DeclaringType.Should().Be(typeof(IInterface));
+			memberInfo.ReflectedType.Should().Be(typeof(IInterface));
+			memberInfo.Should().Be.InstanceOf<PropertyInfo>();
+		}
+
+		[Test]
+		public void WhenAskPropertyOfImplementedInterfaceThenFindItOnType()
+		{
+			var memberInfo = typeof(MyClassWithExplicitImpl).GetPropertyOrFieldMatchingName("SomethingElse");
+			memberInfo.Should().Not.Be.Null();
+			memberInfo.Name.Should().Be("SomethingElse");
+			memberInfo.DeclaringType.Should().Be(typeof(MyClassWithExplicitImpl));
+			memberInfo.ReflectedType.Should().Be(typeof(MyClassWithExplicitImpl));
+			memberInfo.Should().Be.InstanceOf<PropertyInfo>();
+		}
+	}
+}
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-04-28 12:43:58 UTC (rev 5785)
+++ trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-04-28 18:47:30 UTC (rev 5786)
@@ -612,6 +612,7 @@
     <Compile Include="MappingByCode\TypeExtensionsTests\GetFirstImplementorConcreteClassesTest.cs" />
     <Compile Include="MappingByCode\TypeExtensionsTests\GetFirstImplementorTest.cs" />
     <Compile Include="MappingByCode\TypeExtensionsTests\GetMemberFromInterfacesTest.cs" />
+    <Compile Include="MappingByCode\TypeExtensionsTests\GetPropertyOrFieldMatchingNameTest.cs" />
     <Compile Include="MappingByCode\TypeExtensionsTests\TypeExtensionsTest.cs" />
     <Compile Include="MappingByCode\TypeNameUtilTests.cs" />
     <Compile Include="NHSpecificTest\AccessAndCorrectPropertyName\Fixture.cs" />


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5785] trunk/nhibernate/src/NHibernate.Test

[<fab...@us...>]

Revision: 5785
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5785&view=rev
Author:   fabiomaulo
Date:     2011-04-28 12:43:58 +0000 (Thu, 28 Apr 2011)

Log Message:
-----------
Ported some tests

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj

Added Paths:
-----------
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/CompatibilityWithCandidatePersistentMembers.cs
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetFirstImplementorConcreteClassesTest.cs
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetFirstImplementorTest.cs
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetMemberFromInterfacesTest.cs
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/TypeExtensionsTest.cs

Added: trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/CompatibilityWithCandidatePersistentMembers.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/CompatibilityWithCandidatePersistentMembers.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/CompatibilityWithCandidatePersistentMembers.cs	2011-04-28 12:43:58 UTC (rev 5785)
@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+using NHibernate.Mapping.ByCode;
+using NHibernate.Mapping.ByCode.Impl;
+using NUnit.Framework;
+using SharpTestsEx;
+
+namespace NHibernate.Test.MappingByCode.TypeExtensionsTests
+{
+	public class CompatibilityWithCandidatePersistentMembers
+	{
+		public abstract class Geo
+		{
+			public string Descrition { get; set; }
+			protected Geo Parent { get; set; }
+			protected ICollection<Geo> Elements { get; set; }
+		}
+
+		[Test]
+		public void GetFirstPropertyOfTypeShouldUseSameConceptsOfCandidatePersistentMembersProvider()
+		{
+			var memberProvider = new DefaultCandidatePersistentMembersProvider();
+			var properties = memberProvider.GetRootEntityMembers(typeof(Geo));
+			if(properties.Select(p => p.Name).Contains("Parent"))
+			{
+				typeof(Geo).GetFirstPropertyOfType(typeof(Geo)).Should().Not.Be.Null();
+			}
+		}
+	}
+}
\ No newline at end of file

Added: trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetFirstImplementorConcreteClassesTest.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetFirstImplementorConcreteClassesTest.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetFirstImplementorConcreteClassesTest.cs	2011-04-28 12:43:58 UTC (rev 5785)
@@ -0,0 +1,53 @@
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+using SharpTestsEx;
+
+namespace NHibernate.Test.MappingByCode.TypeExtensionsTests
+{
+	public class GetFirstImplementorConcreteClassesTest
+	{
+		private class MyClass1
+		{
+
+		}
+		private class MyClass2 : MyClass1
+		{
+
+		}
+		private class MyClass3 : MyClass2
+		{
+
+		}
+		private class MyClass4 : MyClass3
+		{
+
+		}
+
+		[Test]
+		public void WhenImplIsAtSameLevelThenReturnImplementor()
+		{
+			typeof(MyClass1).GetFirstImplementorOf(typeof(MyClass1)).Should().Be(typeof(MyClass1));
+			typeof(MyClass2).GetFirstImplementorOf(typeof(MyClass2)).Should().Be(typeof(MyClass2));
+			typeof(MyClass3).GetFirstImplementorOf(typeof(MyClass3)).Should().Be(typeof(MyClass3));
+			typeof(MyClass4).GetFirstImplementorOf(typeof(MyClass4)).Should().Be(typeof(MyClass4));
+		}
+
+		[Test]
+		public void WhenImplIsAtDifferentLevelThenReturnImplementor()
+		{
+			typeof(MyClass2).GetFirstImplementorOf(typeof(MyClass1)).Should().Be(typeof(MyClass2));
+			typeof(MyClass3).GetFirstImplementorOf(typeof(MyClass1)).Should().Be(typeof(MyClass2));
+			typeof(MyClass3).GetFirstImplementorOf(typeof(MyClass2)).Should().Be(typeof(MyClass3));
+			typeof(MyClass4).GetFirstImplementorOf(typeof(MyClass1)).Should().Be(typeof(MyClass2));
+			typeof(MyClass4).GetFirstImplementorOf(typeof(MyClass2)).Should().Be(typeof(MyClass3));
+			typeof(MyClass4).GetFirstImplementorOf(typeof(MyClass3)).Should().Be(typeof(MyClass4));
+		}
+
+		[Test]
+		public void WhenImplIsAtUpLevelThenReturnNull()
+		{
+			typeof(MyClass2).GetFirstImplementorOf(typeof(MyClass3)).Should().Be.Null();
+			typeof(MyClass3).GetFirstImplementorOf(typeof(MyClass4)).Should().Be.Null();
+		}
+	}
+}
\ No newline at end of file

Added: trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetFirstImplementorTest.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetFirstImplementorTest.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetFirstImplementorTest.cs	2011-04-28 12:43:58 UTC (rev 5785)
@@ -0,0 +1,78 @@
+using System;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+using SharpTestsEx;
+
+namespace NHibernate.Test.MappingByCode.TypeExtensionsTests
+{
+	public class GetFirstImplementorTest
+	{
+		private interface IInterfaceNoImpl
+		{
+
+		}
+		private interface IInterface1
+		{
+			
+		}
+		private interface IInterface2
+		{
+
+		}
+		private interface IInterface3
+		{
+
+		}
+		private class MyClassNoInterface
+		{
+
+		}
+		private class MyClass1: IInterface1
+		{
+			
+		}
+		private class MyClass2: MyClass1, IInterface2
+		{
+
+		}
+		private class MyClass3 : MyClass2, IInterface3
+		{
+
+		}
+
+		[Test]
+		public void WhenInvalidThenThrows()
+		{
+			Executing.This(()=>((System.Type) null).GetFirstImplementorOf(typeof(IInterfaceNoImpl))).Should().Throw<ArgumentNullException>();
+			Executing.This(() => typeof(IInterfaceNoImpl).GetFirstImplementorOf(null)).Should().Throw<ArgumentNullException>();
+		}
+
+		[Test]
+		public void WhenIsInterfaceThenNoImplementor()
+		{
+			typeof(IInterfaceNoImpl).GetFirstImplementorOf(typeof(IInterfaceNoImpl)).Should().Be.Null();
+		}
+
+		[Test]
+		public void WhenImplAsNoInterfaceThenNoImplementor()
+		{
+			typeof(MyClassNoInterface).GetFirstImplementorOf(typeof(IInterfaceNoImpl)).Should().Be.Null();
+		}
+
+		[Test]
+		public void WhenImplIsAtSameLevelThenReturnImplementor()
+		{
+			typeof(MyClass1).GetFirstImplementorOf(typeof(IInterface1)).Should().Be(typeof(MyClass1));
+			typeof(MyClass2).GetFirstImplementorOf(typeof(IInterface2)).Should().Be(typeof(MyClass2));
+			typeof(MyClass3).GetFirstImplementorOf(typeof(IInterface3)).Should().Be(typeof(MyClass3));
+		}
+
+		[Test]
+		public void WhenImplIsAtDifferentLevelThenReturnImplementor()
+		{
+			typeof(MyClass2).GetFirstImplementorOf(typeof(IInterface1)).Should().Be(typeof(MyClass1));
+			typeof(MyClass3).GetFirstImplementorOf(typeof(IInterface2)).Should().Be(typeof(MyClass2));
+			typeof(MyClass3).GetFirstImplementorOf(typeof(IInterface1)).Should().Be(typeof(MyClass1));
+		}
+	}
+}
\ No newline at end of file

Added: trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetMemberFromInterfacesTest.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetMemberFromInterfacesTest.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/GetMemberFromInterfacesTest.cs	2011-04-28 12:43:58 UTC (rev 5785)
@@ -0,0 +1,82 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+using SharpTestsEx;
+
+namespace NHibernate.Test.MappingByCode.TypeExtensionsTests
+{
+	public class GetMemberFromInterfacesTest
+	{
+		private class BaseEntity
+		{
+			public int Id { get; set; }
+		}
+
+		private interface IEntity
+		{
+			bool IsValid { get; }
+			string Something { get; set; }
+		}
+
+		private interface IHasSomething
+		{
+			string Something { get; set; }
+		}
+
+		private class Person : BaseEntity, IEntity, IHasSomething
+		{
+			private int someField;
+			public string Name { get; set; }
+			public bool IsValid { get { return false; } }
+			public string Something { get; set; }
+		}
+
+		private interface IInheritedHasSomething : IHasSomething
+		{
+			string Blah { get; set; }
+		}
+
+
+		[Test]
+		public void WhenNullArgumentThenThrows()
+		{
+			Executing.This(() => ((MemberInfo)null).GetPropertyFromInterfaces().ToList()).Should().Throw<ArgumentNullException>();
+		}
+
+		[Test]
+		public void WhenNoInterfaceThenEmptyList()
+		{
+			For<BaseEntity>.Property(x=> x.Id).GetPropertyFromInterfaces().Should().Be.Empty();
+		}
+
+		[Test]
+		public void WhenFieldThenEmptyList()
+		{
+			ForClass<Person>.Field("someField").GetPropertyFromInterfaces().Should().Be.Empty();
+		}
+
+		[Test]
+		public void WhenOneInterfaceThenReturnMemberInfoOfInterface()
+		{
+			var members = For<Person>.Property(x => x.IsValid).GetPropertyFromInterfaces();
+			members.Single().Should().Be(For<IEntity>.Property(x=> x.IsValid));
+		}
+
+		[Test]
+		public void WhenTwoInterfacesThenReturnMemberInfoOfEachInterface()
+		{
+			var members = For<Person>.Property(x => x.Something).GetPropertyFromInterfaces();
+			members.Should().Contain(For<IEntity>.Property(x => x.Something));
+			members.Should().Contain(For<IHasSomething>.Property(x => x.Something));
+		}
+
+		[Test]
+		public void WhenPropertyOfInterfaceThenNotThrows()
+		{
+			var member = For<IInheritedHasSomething>.Property(x => x.Blah);
+			member.Executing(x=> x.GetPropertyFromInterfaces().Any()).NotThrows();
+		}
+	}
+}
\ No newline at end of file

Added: trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/TypeExtensionsTest.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/TypeExtensionsTest.cs	                        (rev 0)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/TypeExtensionsTests/TypeExtensionsTest.cs	2011-04-28 12:43:58 UTC (rev 5785)
@@ -0,0 +1,207 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Reflection;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+using SharpTestsEx;
+
+namespace NHibernate.Test.MappingByCode.TypeExtensionsTests
+{
+	public class TypeExtensionsTest
+	{
+		private const BindingFlags BindingFlagsIncludePrivate = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public;
+
+		[Test]
+		public void CanDetermineDictionaryKeyType()
+		{
+			typeof (IDictionary<string, int>).DetermineDictionaryKeyType().Should().Be.EqualTo<string>();
+		}
+
+		[Test]
+		public void WhenNoGenericDictionaryThenDetermineNullDictionaryKeyType()
+		{
+			typeof(IEnumerable<string>).DetermineDictionaryKeyType().Should().Be.Null();
+		}
+
+		[Test]
+		public void CanDetermineDictionaryValueType()
+		{
+			typeof(IDictionary<string, int>).DetermineDictionaryValueType().Should().Be.EqualTo<int>();
+		}
+
+		[Test]
+		public void WhenNoGenericDictionaryThenDetermineNullDictionaryValueType()
+		{
+			typeof(IEnumerable<string>).DetermineDictionaryValueType().Should().Be.Null();
+		}
+
+		private class MyBaseClass
+		{
+			public string BaseProperty { get; set; }
+			public bool BaseBool { get; set; }
+			private double SomethingPrivate { get; set; }
+		}
+		private class MyClass : MyBaseClass
+		{
+			
+		}
+
+		[Test]
+		public void DecodeMemberAccessExpressionShouldReturnMemberOfDeclaringClass()
+		{
+			Mapping.ByCode.TypeExtensions.DecodeMemberAccessExpression<MyClass>(mc => mc.BaseProperty).Satisfy(
+				mi => mi.ReflectedType == typeof(MyBaseClass) && mi.DeclaringType == typeof(MyBaseClass));
+			Mapping.ByCode.TypeExtensions.DecodeMemberAccessExpression<MyClass>(mc => mc.BaseBool).Satisfy(
+				mi => mi.ReflectedType == typeof(MyBaseClass) && mi.DeclaringType == typeof(MyBaseClass));
+		}
+
+		[Test]
+		public void GenericDecodeMemberAccessExpressionShouldReturnMemberOfDeclaringClass()
+		{
+			Mapping.ByCode.TypeExtensions.DecodeMemberAccessExpression<MyClass, string>(mc => mc.BaseProperty).Satisfy(
+				mi => mi.ReflectedType == typeof(MyBaseClass) && mi.DeclaringType == typeof(MyBaseClass));
+			Mapping.ByCode.TypeExtensions.DecodeMemberAccessExpression<MyClass, bool>(mc => mc.BaseBool).Satisfy(
+				mi => mi.ReflectedType == typeof(MyBaseClass) && mi.DeclaringType == typeof(MyBaseClass));
+		}
+
+		[Test]
+		public void DecodeMemberAccessExpressionOfShouldReturnMemberOfRequiredClass()
+		{
+			Mapping.ByCode.TypeExtensions.DecodeMemberAccessExpressionOf<MyClass>(mc => mc.BaseProperty).Satisfy(
+				mi => mi.ReflectedType == typeof (MyClass) && mi.DeclaringType == typeof (MyBaseClass));
+			Mapping.ByCode.TypeExtensions.DecodeMemberAccessExpressionOf<MyClass>(mc => mc.BaseBool).Satisfy(
+				mi => mi.ReflectedType == typeof(MyClass) && mi.DeclaringType == typeof(MyBaseClass));
+		}
+
+		[Test]
+		public void GenericDecodeMemberAccessExpressionOfShouldReturnMemberOfRequiredClass()
+		{
+			Mapping.ByCode.TypeExtensions.DecodeMemberAccessExpressionOf<MyClass, string>(mc => mc.BaseProperty).Satisfy(
+				mi => mi.ReflectedType == typeof(MyClass) && mi.DeclaringType == typeof(MyBaseClass));
+			Mapping.ByCode.TypeExtensions.DecodeMemberAccessExpressionOf<MyClass, bool>(mc => mc.BaseBool).Satisfy(
+				mi => mi.ReflectedType == typeof(MyClass) && mi.DeclaringType == typeof(MyBaseClass));
+		}
+
+		[Test]
+		public void GetBaseTypesIncludesInterfaces()
+		{
+			typeof (Collection<>).GetBaseTypes().Should().Contain(typeof (IEnumerable));
+		}
+
+		private interface IEntity<T>
+		{
+			T Id { get; set; }
+		}
+		private abstract class AbstractEntity<T> : IEntity<T>
+		{
+			public abstract T Id { get; set; }
+			public abstract bool BaseBool { get; set; }
+		}
+
+		private class BaseEntity : AbstractEntity<int>
+		{
+			public override int Id { get; set; }
+
+			public override bool BaseBool { get; set; }
+		}
+		private class MyEntity: BaseEntity
+		{
+		}
+
+		[Test]
+		public void DecodeMemberAccessExpressionOfWithGenericShouldReturnMemberOfRequiredClass()
+		{
+			Mapping.ByCode.TypeExtensions.DecodeMemberAccessExpressionOf<MyEntity>(mc => mc.Id).Satisfy(
+				mi => mi.ReflectedType == typeof(MyEntity) && mi.DeclaringType == typeof(BaseEntity));
+			Mapping.ByCode.TypeExtensions.DecodeMemberAccessExpressionOf<MyEntity>(mc => mc.BaseBool).Satisfy(
+				mi => mi.ReflectedType == typeof(MyEntity) && mi.DeclaringType == typeof(BaseEntity));
+		}
+
+		[Test]
+		public void WhenBaseIsAbstractGenericGetMemberFromDeclaringType()
+		{
+			var mi = typeof(MyEntity).GetProperty("Id", typeof(int));
+			var declaringMi = mi.GetMemberFromDeclaringType();
+			declaringMi.DeclaringType.Should().Be<BaseEntity>();
+			declaringMi.ReflectedType.Should().Be<BaseEntity>();
+		}
+
+		[Test]
+		public void WhenBaseIsAbstractGetMemberFromDeclaringType()
+		{
+			var mi = typeof(MyEntity).GetProperty("BaseBool", typeof(bool));
+			var declaringMi = mi.GetMemberFromDeclaringType();
+			declaringMi.DeclaringType.Should().Be<BaseEntity>();
+			declaringMi.ReflectedType.Should().Be<BaseEntity>();
+		}
+
+		[Test]
+		public void GetFirstPropertyOfTypeWithNulls()
+		{
+			System.Type myType = null;
+			myType.GetFirstPropertyOfType(typeof (int), BindingFlagsIncludePrivate).Should().Be.Null();
+			myType = typeof (Array);
+			myType.GetFirstPropertyOfType(null, BindingFlagsIncludePrivate).Should().Be.Null();
+		}
+
+		[Test]
+		public void GetFirstPropertyOfType_WhenPropertyExistThenFindProperty()
+		{
+			typeof (MyBaseClass).GetFirstPropertyOfType(typeof (string)).Should().Be(
+				typeof (MyBaseClass).GetProperty("BaseProperty"));
+			typeof (MyBaseClass).GetFirstPropertyOfType(typeof (bool)).Should().Be(typeof (MyBaseClass).GetProperty("BaseBool"));
+			typeof (MyBaseClass).GetFirstPropertyOfType(typeof (double), BindingFlagsIncludePrivate).Should().Be(
+				typeof (MyBaseClass).GetProperty("SomethingPrivate", BindingFlagsIncludePrivate));
+		}
+
+		[Test]
+		public void GetFirstPropertyOfType_WhenPropertyNotExistThenNull()
+		{
+			typeof (MyBaseClass).GetFirstPropertyOfType(typeof (float)).Should().Be.Null();
+			// typeof (MyBaseClass).GetFirstPropertyOfType(typeof (double)).Should().Be.Null(); <= by default check private prop.
+		}
+
+		private interface IMyEntity : IEntity<Guid>
+		{
+
+		}
+
+		[Test]
+		public void WhenDecodeMemberAccessExpressionOfOnInheritedEntityInterfaceThenDecodeMember()
+		{
+			Mapping.ByCode.TypeExtensions.DecodeMemberAccessExpressionOf<IMyEntity>(m => m.Id).Should().Not.Be.Null();
+			Mapping.ByCode.TypeExtensions.DecodeMemberAccessExpressionOf<IMyEntity, Guid>(m => m.Id).Should().Not.Be.Null();
+		}
+
+		[Test]
+		public void TheSequenceOfGetHierarchyFromBaseShouldStartFromBaseClassUpToGivenClass()
+		{
+			// excluding System.Object
+			typeof(MyEntity).GetHierarchyFromBase().Should().Have.SameSequenceAs(typeof(AbstractEntity<int>), typeof(BaseEntity), typeof(MyEntity));
+		}
+
+		[Test]
+		public void GetFirstPropertyOfType_WhenDelegateIsNullThenThrow()
+		{
+			var myType = typeof(Array);
+			Executing.This(()=> myType.GetFirstPropertyOfType(typeof(int), BindingFlagsIncludePrivate, null)).Should().Throw<ArgumentNullException>();
+		}
+
+		[Test]
+		public void GetFirstPropertyOfType_WhenAsDelegateThenUseDelegateToFilterProperties()
+		{
+			typeof (MyBaseClass).GetFirstPropertyOfType(typeof (string), BindingFlags.Public | BindingFlags.Instance, x => false).Should().Be.Null();
+			typeof (MyBaseClass).GetFirstPropertyOfType(typeof (string), BindingFlags.Public | BindingFlags.Instance, x => true).Should().Be(
+				typeof (MyBaseClass).GetProperty("BaseProperty"));
+		}
+
+		[Test]
+		public void HasPublicPropertyOf_WhenAsDelegateThenUseDelegateToFilterProperties()
+		{
+			typeof(MyBaseClass).HasPublicPropertyOf(typeof(string), x => false).Should().Be.False();
+			typeof(MyBaseClass).HasPublicPropertyOf(typeof(string), x => true).Should().Be.True();
+		}
+	}
+}
\ No newline at end of file

Modified: trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-04-28 10:36:52 UTC (rev 5784)
+++ trunk/nhibernate/src/NHibernate.Test/NHibernate.Test.csproj	2011-04-28 12:43:58 UTC (rev 5785)
@@ -608,6 +608,11 @@
     <Compile Include="MappingByCode\NatureDemo\Naturalness\StateProvince.cs" />
     <Compile Include="MappingByCode\NatureDemo\Naturalness\User.cs" />
     <Compile Include="MappingByCode\NatureDemo\Naturalness\Zoo.cs" />
+    <Compile Include="MappingByCode\TypeExtensionsTests\CompatibilityWithCandidatePersistentMembers.cs" />
+    <Compile Include="MappingByCode\TypeExtensionsTests\GetFirstImplementorConcreteClassesTest.cs" />
+    <Compile Include="MappingByCode\TypeExtensionsTests\GetFirstImplementorTest.cs" />
+    <Compile Include="MappingByCode\TypeExtensionsTests\GetMemberFromInterfacesTest.cs" />
+    <Compile Include="MappingByCode\TypeExtensionsTests\TypeExtensionsTest.cs" />
     <Compile Include="MappingByCode\TypeNameUtilTests.cs" />
     <Compile Include="NHSpecificTest\AccessAndCorrectPropertyName\Fixture.cs" />
     <Compile Include="NHSpecificTest\AccessAndCorrectPropertyName\Model.cs" />


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5784] trunk/nhibernate/build-common/common.xml

[<fab...@us...>]

Revision: 5784
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5784&view=rev
Author:   fabiomaulo
Date:     2011-04-28 10:36:52 +0000 (Thu, 28 Apr 2011)

Log Message:
-----------
Fixed version number of the trunk

Modified Paths:
--------------
    trunk/nhibernate/build-common/common.xml

Modified: trunk/nhibernate/build-common/common.xml
===================================================================
--- trunk/nhibernate/build-common/common.xml	2011-04-28 05:44:25 UTC (rev 5783)
+++ trunk/nhibernate/build-common/common.xml	2011-04-28 10:36:52 UTC (rev 5784)
@@ -84,7 +84,7 @@
 		effectively SP0).
 	-->
 
-	<property name="project.version" value="3.2.0.Alpha2" overwrite="false" />
+	<property name="project.version" value="3.2.0.Alpha3" overwrite="false" />
 
 	<!-- Compute short project version (major.minor) using a regex -->
 	<regex input="${project.version}" pattern="^(?'shortversion'\d+\.\d+)" />


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5783] trunk/nhibernate/src/NHibernate/Driver/ NpgsqlDriver.cs

[<pa...@us...>]

Revision: 5783
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5783&view=rev
Author:   patearl
Date:     2011-04-28 05:44:25 +0000 (Thu, 28 Apr 2011)

Log Message:
-----------
PostgreSQL: Fixed currency parameter type.

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Driver/NpgsqlDriver.cs

Modified: trunk/nhibernate/src/NHibernate/Driver/NpgsqlDriver.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Driver/NpgsqlDriver.cs	2011-04-28 04:20:33 UTC (rev 5782)
+++ trunk/nhibernate/src/NHibernate/Driver/NpgsqlDriver.cs	2011-04-28 05:44:25 UTC (rev 5783)
@@ -1,3 +1,5 @@
+using System.Data;
+
 namespace NHibernate.Driver
 {
 	/// <summary>
@@ -72,5 +74,13 @@
 		{
 			get { return true; }
 		}
+
+        protected override void InitializeParameter(IDbDataParameter dbParam, string name, SqlTypes.SqlType sqlType)
+        {
+            base.InitializeParameter(dbParam, name, sqlType);
+
+            if (sqlType.DbType == DbType.Currency)
+                dbParam.DbType = DbType.Decimal;
+        }
 	}
 }


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5782] trunk/nhibernate/src/NHibernate/Dialect/ Schema/PostgreSQLMetadata.cs

[<pa...@us...>]

Revision: 5782
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5782&view=rev
Author:   patearl
Date:     2011-04-28 04:20:33 +0000 (Thu, 28 Apr 2011)

Log Message:
-----------
PostgreSQL: Support reserved word retrieval.

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Dialect/Schema/PostgreSQLMetadata.cs

Modified: trunk/nhibernate/src/NHibernate/Dialect/Schema/PostgreSQLMetadata.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Dialect/Schema/PostgreSQLMetadata.cs	2011-04-28 03:33:35 UTC (rev 5781)
+++ trunk/nhibernate/src/NHibernate/Dialect/Schema/PostgreSQLMetadata.cs	2011-04-28 04:20:33 UTC (rev 5782)
@@ -13,13 +13,6 @@
 		{
 			return new PostgreSQLTableMetadata(rs, this, extras);
 		}
-		
-		public override ISet<string> GetReservedWords()
-		{
-			// NpgsqlDriver does not currently (2011/03/30) support this feature, so the 
-			// base class implementation has to be overriden
-			return new HashedSet<string>();
-		}
 	}
 
 	public class PostgreSQLTableMetadata : AbstractTableMetadata


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5781] trunk/nhibernate/lib/teamcity/postgresql/ Npgsql.dll

[<pa...@us...>]

Revision: 5781
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5781&view=rev
Author:   patearl
Date:     2011-04-28 03:33:35 +0000 (Thu, 28 Apr 2011)

Log Message:
-----------
Tests: Latest Npgsql from trunk to fix test failures.

Modified Paths:
--------------
    trunk/nhibernate/lib/teamcity/postgresql/Npgsql.dll

Modified: trunk/nhibernate/lib/teamcity/postgresql/Npgsql.dll
===================================================================
(Binary files differ)


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5780] trunk/nhibernate/src/NHibernate

[<fab...@us...>]

Revision: 5780
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5780&view=rev
Author:   fabiomaulo
Date:     2011-04-27 22:32:04 +0000 (Wed, 27 Apr 2011)

Log Message:
-----------
Passing test to check we are merging all

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/FakeModelExplicitDeclarationsHolder.cs
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/ModelExplicitDeclarationsHolderMergeTest.cs

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/FakeModelExplicitDeclarationsHolder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/FakeModelExplicitDeclarationsHolder.cs	2011-04-27 22:04:24 UTC (rev 5779)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/FakeModelExplicitDeclarationsHolder.cs	2011-04-27 22:32:04 UTC (rev 5780)
@@ -182,8 +182,6 @@
 
 		public void AddAsTablePerClassHierarchyEntity(System.Type type) {}
 
-		public void AddAsTablePerClassHierarchyJoinEntity(System.Type type) {}
-
 		public void AddAsTablePerConcreteClassEntity(System.Type type) {}
 
 		public void AddAsOneToOneRelation(MemberInfo member) {}

Modified: trunk/nhibernate/src/NHibernate.Test/MappingByCode/ModelExplicitDeclarationsHolderMergeTest.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/ModelExplicitDeclarationsHolderMergeTest.cs	2011-04-27 22:04:24 UTC (rev 5779)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/ModelExplicitDeclarationsHolderMergeTest.cs	2011-04-27 22:32:04 UTC (rev 5780)
@@ -1,3 +1,5 @@
+using System.Collections.Generic;
+using System.Linq;
 using System.Reflection;
 using NHibernate.Mapping.ByCode;
 using NHibernate.Mapping.ByCode.Impl;
@@ -8,6 +10,299 @@
 {
 	public class ModelExplicitDeclarationsHolderMergeTest
 	{
+		private class ExplicitDeclarationsHolderMock: IModelExplicitDeclarationsHolder
+		{
+			public ExplicitDeclarationsHolderMock()
+			{
+				PropertiesGettersUsed = new HashSet<string>();
+			}
+			private readonly HashSet<MemberInfo> any = new HashSet<MemberInfo>();
+			private readonly HashSet<MemberInfo> arrays = new HashSet<MemberInfo>();
+			private readonly HashSet<MemberInfo> bags = new HashSet<MemberInfo>();
+			private readonly HashSet<System.Type> components = new HashSet<System.Type>();
+			private readonly HashSet<MemberInfo> dictionaries = new HashSet<MemberInfo>();
+			private readonly HashSet<MemberInfo> idBags = new HashSet<MemberInfo>();
+			private readonly HashSet<MemberInfo> lists = new HashSet<MemberInfo>();
+			private readonly HashSet<MemberInfo> manyToManyRelations = new HashSet<MemberInfo>();
+			private readonly HashSet<MemberInfo> manyToOneRelations = new HashSet<MemberInfo>();
+			private readonly HashSet<MemberInfo> naturalIds = new HashSet<MemberInfo>();
+			private readonly HashSet<MemberInfo> oneToManyRelations = new HashSet<MemberInfo>();
+			private readonly HashSet<MemberInfo> oneToOneRelations = new HashSet<MemberInfo>();
+			private readonly HashSet<MemberInfo> poids = new HashSet<MemberInfo>();
+			private readonly HashSet<MemberInfo> composedIds = new HashSet<MemberInfo>();
+			private readonly HashSet<MemberInfo> properties = new HashSet<MemberInfo>();
+			private readonly HashSet<MemberInfo> dynamicComponents = new HashSet<MemberInfo>();
+			private readonly HashSet<MemberInfo> persistentMembers = new HashSet<MemberInfo>();
+			private readonly HashSet<System.Type> rootEntities = new HashSet<System.Type>();
+			private readonly HashSet<MemberInfo> sets = new HashSet<MemberInfo>();
+			private readonly HashSet<SplitDefinition> splitDefinitions = new HashSet<SplitDefinition>();
+			private readonly HashSet<System.Type> tablePerClassEntities = new HashSet<System.Type>();
+			private readonly HashSet<System.Type> tablePerClassHierarchyEntities = new HashSet<System.Type>();
+			private readonly HashSet<System.Type> tablePerConcreteClassEntities = new HashSet<System.Type>();
+			private readonly HashSet<MemberInfo> versionProperties = new HashSet<MemberInfo>();
+
+			public HashSet<string> PropertiesGettersUsed { get; set; }
+
+			#region IModelExplicitDeclarationsHolder Members
+
+			public IEnumerable<System.Type> RootEntities
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("RootEntities");
+					return rootEntities;
+				}
+			}
+
+			public IEnumerable<System.Type> Components
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("Components");
+					return components;
+				}
+			}
+
+			public IEnumerable<System.Type> TablePerClassEntities
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("TablePerClassEntities");
+					return tablePerClassEntities;
+				}
+			}
+
+			public IEnumerable<System.Type> TablePerClassHierarchyEntities
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("TablePerClassHierarchyEntities");
+					return tablePerClassHierarchyEntities;
+				}
+			}
+
+			public IEnumerable<System.Type> TablePerConcreteClassEntities
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("TablePerConcreteClassEntities");
+					return tablePerConcreteClassEntities;
+				}
+			}
+
+			public IEnumerable<MemberInfo> OneToOneRelations
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("OneToOneRelations");
+					return oneToOneRelations;
+				}
+			}
+
+			public IEnumerable<MemberInfo> ManyToOneRelations
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("ManyToOneRelations");
+					return manyToOneRelations;
+				}
+			}
+
+			public IEnumerable<MemberInfo> ManyToManyRelations
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("ManyToManyRelations");
+					return manyToManyRelations;
+				}
+			}
+
+			public IEnumerable<MemberInfo> OneToManyRelations
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("OneToManyRelations");
+					return oneToManyRelations;
+				}
+			}
+
+			public IEnumerable<MemberInfo> Any
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("Any");
+					return any;
+				}
+			}
+
+			public IEnumerable<MemberInfo> Poids
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("Poids");
+					return poids;
+				}
+			}
+
+			public IEnumerable<MemberInfo> ComposedIds
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("ComposedIds");
+					return composedIds;
+				}
+			}
+
+			public IEnumerable<MemberInfo> VersionProperties
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("VersionProperties");
+					return versionProperties;
+				}
+			}
+
+			public IEnumerable<MemberInfo> NaturalIds
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("NaturalIds");
+					return naturalIds;
+				}
+			}
+
+			public IEnumerable<MemberInfo> Sets
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("Sets");
+					return sets;
+				}
+			}
+
+			public IEnumerable<MemberInfo> Bags
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("Bags");
+					return bags;
+				}
+			}
+
+			public IEnumerable<MemberInfo> IdBags
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("IdBags");
+					return idBags;
+				}
+			}
+
+			public IEnumerable<MemberInfo> Lists
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("Lists");
+					return lists;
+				}
+			}
+
+			public IEnumerable<MemberInfo> Arrays
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("Arrays");
+					return arrays;
+				}
+			}
+
+			public IEnumerable<MemberInfo> Dictionaries
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("Dictionaries");
+					return dictionaries;
+				}
+			}
+
+			public IEnumerable<MemberInfo> Properties
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("Properties");
+					return properties;
+				}
+			}
+
+			public IEnumerable<MemberInfo> DynamicComponents
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("DynamicComponents");
+					return dynamicComponents;
+				}
+			}
+
+			public IEnumerable<MemberInfo> PersistentMembers
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("PersistentMembers");
+					return persistentMembers;
+				}
+			}
+
+			public IEnumerable<SplitDefinition> SplitDefinitions
+			{
+				get
+				{
+					PropertiesGettersUsed.Add("SplitDefinitions");
+					return splitDefinitions;
+				}
+			}
+
+			public IEnumerable<string> GetSplitGroupsFor(System.Type type)
+			{
+				return Enumerable.Empty<string>();
+			}
+
+			public string GetSplitGroupFor(MemberInfo member)
+			{
+				return null;
+			}
+
+			public System.Type GetDynamicComponentTemplate(MemberInfo member)
+			{
+				return null;
+			}
+
+			public void AddAsRootEntity(System.Type type) { }
+			public void AddAsComponent(System.Type type) { }
+			public void AddAsTablePerClassEntity(System.Type type) { }
+			public void AddAsTablePerClassHierarchyEntity(System.Type type) { }
+			public void AddAsTablePerConcreteClassEntity(System.Type type) { }
+			public void AddAsOneToOneRelation(MemberInfo member) { }
+			public void AddAsManyToOneRelation(MemberInfo member) { }
+			public void AddAsManyToManyRelation(MemberInfo member) { }
+			public void AddAsOneToManyRelation(MemberInfo member) { }
+			public void AddAsAny(MemberInfo member) { }
+			public void AddAsPoid(MemberInfo member) { }
+			public void AddAsPartOfComposedId(MemberInfo member) { }
+			public void AddAsVersionProperty(MemberInfo member) { }
+			public void AddAsNaturalId(MemberInfo member) { }
+			public void AddAsSet(MemberInfo member) { }
+			public void AddAsBag(MemberInfo member) { }
+			public void AddAsIdBag(MemberInfo member) { }
+			public void AddAsList(MemberInfo member) { }
+			public void AddAsArray(MemberInfo member) { }
+			public void AddAsMap(MemberInfo member) { }
+			public void AddAsProperty(MemberInfo member) { }
+			public void AddAsPersistentMember(MemberInfo member) { }
+			public void AddAsPropertySplit(SplitDefinition definition) { }
+			public void AddAsDynamicComponent(MemberInfo member, System.Type componentTemplate) { }
+
+			#endregion
+		}
 		private readonly MemberInfo property = typeof (MyClass).GetProperty("Bar");
 
 		[Test]
@@ -282,6 +577,21 @@
 			destination.ComposedIds.Should().Have.Count.EqualTo(1);
 		}
 
+		[Test]
+		public void MergeShouldGetAllPropertiesOfPatternsAppliersHolderOfBothSide()
+		{
+			// this test is to check that, at least, we are getting all properties (to avoid to forget something)
+			string[] propertiesOfIPatternsAppliersHolder =
+				typeof(IModelExplicitDeclarationsHolder).GetProperties().Select(x => x.Name).ToArray();
+
+			var first = new ExplicitDeclarationsHolderMock();
+			var second = new ExplicitDeclarationsHolderMock();
+
+			first.Merge(second);
+
+			second.PropertiesGettersUsed.Should().Have.SameValuesAs(propertiesOfIPatternsAppliersHolder);
+		}
+
 		#region Nested type: MyClass
 
 		private class MyClass


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[Nhibernate-commit] SF.net SVN: nhibernate:[5779] trunk/nhibernate/src/NHibernate

[<fab...@us...>]

Revision: 5779
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5779&view=rev
Author:   fabiomaulo
Date:     2011-04-27 22:04:24 +0000 (Wed, 27 Apr 2011)

Log Message:
-----------
Fixed merge of component-as-id customization

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersHolder.cs
    trunk/nhibernate/src/NHibernate.Test/MappingByCode/CustomizerHolderMergeTest.cs

Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersHolder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersHolder.cs	2011-04-27 21:53:31 UTC (rev 5778)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersHolder.cs	2011-04-27 22:04:24 UTC (rev 5779)
@@ -354,6 +354,7 @@
 			MergeDictionary(mapKeyManyToManyCustomizers, source.mapKeyManyToManyCustomizers);
 			MergeDictionary(mapKeyElementCustomizers, source.mapKeyElementCustomizers);
 			MergeDictionary(dynamicComponentCustomizers, source.dynamicComponentCustomizers);
+			MergeDictionary(componentAsIdPropertyCustomizers, source.componentAsIdPropertyCustomizers);
 		}
 
 		#endregion

Modified: trunk/nhibernate/src/NHibernate.Test/MappingByCode/CustomizerHolderMergeTest.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/CustomizerHolderMergeTest.cs	2011-04-27 21:53:31 UTC (rev 5778)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/CustomizerHolderMergeTest.cs	2011-04-27 22:04:24 UTC (rev 5779)
@@ -343,5 +343,18 @@
 			called.Should().Be.True();
 		}
 
+		[Test]
+		public void MergeShouldMergeComponentAsIdAttributesMapper()
+		{
+			var emptyHolder = new CustomizersHolder();
+			var holder = new CustomizersHolder();
+			var called = false;
+
+			holder.AddCustomizer(propertyPath, (IComponentAsIdAttributesMapper x) => called = true);
+			emptyHolder.Merge(holder);
+			emptyHolder.InvokeCustomizers(propertyPath, (IComponentAsIdAttributesMapper)null);
+
+			called.Should().Be.True();
+		}
 	}
 }
\ No newline at end of file


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.