Merge branch 'cleaner_override' of https://github.com/icambron/fluent-nhibernate into icambron-cleaner_override

Conflicts:
	src/FluentNHibernate/Automapping/Alterations/AutoMappingOverrideAlteration.cs

Author: jagregory

src/FluentNHibernate/Automapping/Alterations/AutoMappingOverrideAlteration.cs

@@ -34,37 +34,17 @@ public void Alter(AutoPersistenceModel model)
         {
             // find all types deriving from IAutoMappingOverride<T>
             var types = from type in assembly.GetExportedTypes()
-						where !type.IsAbstract
+                        where !type.IsAbstract
                         let entity = (from interfaceType in type.GetInterfaces()
                                       where interfaceType.IsGenericType && interfaceType.GetGenericTypeDefinition() == typeof(IAutoMappingOverride<>)
                                       select interfaceType.GetGenericArguments()[0]).FirstOrDefault()
                         where entity != null
-                        select new { OverrideType = type, EntityType = entity };
+                        select type;
 
-            foreach (var typeMatch in types)
+            foreach (var type in types)
             {
-                var mappingOverride = Activator.CreateInstance(typeMatch.OverrideType);
-                var autoMapType = typeof(AutoMapping<>).MakeGenericType(typeMatch.EntityType);
-                var mapping = (IMappingProvider)Activator.CreateInstance(autoMapType, new List<Member>());
-
-                // HACK: call the Override method with the generic AutoMapping<T>
-                var overrideMethod = typeMatch.OverrideType
-                    .GetMethod("Override");
-
-                GetType()
-                    .GetMethod("AddOverride", BindingFlags.Instance | BindingFlags.NonPublic)
-                    .MakeGenericMethod(typeMatch.EntityType)
-                    .Invoke(this, new[] { model, typeMatch.EntityType, mappingOverride });
+            	model.Override(type);
             }
         }
-
-        private void AddOverride<T>(AutoPersistenceModel model, Type entity, IAutoMappingOverride<T> mappingOverride)
-        {
-            model.AddOverride(entity, x =>
-            {
-                if (x is AutoMapping<T>)
-                    mappingOverride.Override((AutoMapping<T>)x);
-            });
-        }
     }
 }

src/FluentNHibernate/Automapping/AutoPersistenceModel.cs

@@ -345,6 +345,39 @@ public AutoPersistenceModel Override<T>(Action<AutoMapping<T>> populateMap)
             return this;
         }
 
+		/// <summary>
+		/// Adds an IAutoMappingOverride reflectively
+		/// </summary>
+		/// <param name="overrideType">Override type, expected to be an IAutoMappingOverride</param>
+		public void Override(Type overrideType)
+		{
+			Type overrideInterface = overrideType.GetInterfaces()
+				.Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IAutoMappingOverride<>) && x.GetGenericArguments().Length > 0)
+				.FirstOrDefault();
+			if (overrideInterface != null)
+			{
+				Type entityType = overrideInterface.GetGenericArguments().First();
+				Type autoMappingType = typeof(AutoMapping<>).MakeGenericType(entityType);
+				AddOverride(entityType, x =>
+				{
+					if (x.GetType().IsAssignableFrom(autoMappingType))
+					{
+						var overrideInstance = Activator.CreateInstance(overrideType);
+						GetType()
+							.GetMethod("OverrideHelper", BindingFlags.NonPublic | BindingFlags.Instance)
+							.MakeGenericMethod(entityType)
+							.Invoke(this, new [] {x, overrideInstance});
+					}
+				});
+			}
+		}
+
+		//called reflectively from method above
+		private void OverrideHelper<T>(AutoMapping<T> x, IAutoMappingOverride<T> mappingOverride)
+		{
+			mappingOverride.Override(x);
+		}
+
         /// <summary>
         /// Override all mappings.
         /// </summary>