@@ -17,14 +17,37 @@ namespace FluentNHibernate.Testing.PersistenceModelTests public void SetUp() { providers = new List<IIndeterminateSubclassMappingProvider>(); + } + + [Test] + public void Should_add_subclass_that_implements_the_parent_interface() + { + /* The Parent is the IFoo interface the desired results + * of this test is the inclusion of the Foo<T> through the + * GenericFooMap<T> subclass mapping. + */ + fooMapping = ((IMappingProvider)new FooMap()).GetClassMapping(); + + providers.Add(new StringFooMap()); + var sut = CreateSut(); + sut.ProcessClass(fooMapping); + Assert.AreEqual(1, fooMapping.Subclasses.Count()); + Assert.AreEqual(1, fooMapping.Subclasses.Where(sub => sub.Type.Equals(typeof(Foo<string>))).Count()); } - [Test, Ignore("Issue 340: http://code.google.com/p/fluent-nhibernate/issues/detail?id=340")] - public void Should_add_subclass_that_implement_the_parent_interface() + [Test] + public void Should_add_subclass_that_implements_the_parent_base() { + /* The Parent is the FooBase class the desired results + * of this test is the inclusion of the Foo<T> through the + * GenericFooMap<T> subclass mapping. + */ + + fooMapping = ((IMappingProvider)new BaseMap()).GetClassMapping(); + providers.Add(new StringFooMap()); - var sut = new SeparateSubclassVisitor(providers); + var sut = CreateSut(); sut.ProcessClass(fooMapping); Assert.AreEqual(1, fooMapping.Subclasses.Count()); Assert.AreEqual(1, fooMapping.Subclasses.Where(sub => sub.Type.Equals(typeof(Foo<string>))).Count()); @@ -33,45 +56,114 @@ namespace FluentNHibernate.Testing.PersistenceModelTests [Test] public void Should_not_add_subclassmap_that_does_not_implement_parent_interface() { - providers.Add(new OtherMap()); - var sut = new SeparateSubclassVisitor(providers); + /* The Parent is the IFoo interface the desired results + * of this test is the exclusion of the StandAlone class + * since it does not implement the interface. + */ + + fooMapping = ((IMappingProvider)new FooMap()).GetClassMapping(); + + providers.Add(new StandAloneMap()); + var sut = CreateSut(); sut.ProcessClass(fooMapping); Assert.AreEqual(0, fooMapping.Subclasses.Count()); } - private interface IFoo + [Test] + public void Should_not_add_subclassmap_that_does_not_implement_parent_base() { - } + /* The Parent is the FooBase class the desired results + * of this test is the exclusion of the StandAlone class + * since it does not implement the interface. + */ - private interface IOther - { - IFoo Foo { get; } + fooMapping = ((IMappingProvider)new BaseMap()).GetClassMapping(); + + providers.Add(new StandAloneMap()); + var sut = CreateSut(); + sut.ProcessClass(fooMapping); + Assert.AreEqual(0, fooMapping.Subclasses.Count()); } - private class Base + [Test] + public void Should_not_add_subclassmap_that_implements_a_subclass_of_the_parent_interface() { - } + /* The Parent is the IFoo interface the desired results + * of this test is the inclusion of the BaseImpl class and + * the exclusion of the Foo<T> class since it implements + * the BaseImpl class which already implements FooBase. + */ - private class Other : Base { } + fooMapping = ((IMappingProvider)new FooMap()).GetClassMapping(); - private class Foo<T> : Base, IFoo - { + providers.Add(new BaseImplMap()); + providers.Add(new StringFooMap()); + var sut = CreateSut(); + sut.ProcessClass(fooMapping); + Assert.AreEqual(1, fooMapping.Subclasses.Count()); + Assert.AreEqual(1, fooMapping.Subclasses.Where(sub => sub.Type.Equals(typeof(BaseImpl))).Count()); } - private class FooMap : ClassMap<IFoo> + [Test] + public void Should_not_add_subclassmap_that_implements_a_subclass_of_the_parent_base() { - } + /* The Parent is the FooBase class the desired results + * of this test is the inclusion of the BaseImpl class and + * the exclusion of the Foo<T> class since it implements + * the BaseImpl class which already implements FooBase. + */ - private abstract class SubFooMap<T> : SubclassMap<Foo<T>> - { - } + fooMapping = ((IMappingProvider)new BaseMap()).GetClassMapping(); - private class StringFooMap : SubFooMap<string> - { + providers.Add(new BaseImplMap()); + providers.Add(new StringFooMap()); + var sut = CreateSut(); + sut.ProcessClass(fooMapping); + Assert.AreEqual(1, fooMapping.Subclasses.Count()); + Assert.AreEqual(1, fooMapping.Subclasses.Where(sub => sub.Type.Equals(typeof(BaseImpl))).Count()); } - private class OtherMap : SubclassMap<Other> + private SeparateSubclassVisitor CreateSut() { + return new SeparateSubclassVisitor(providers); } + + + public interface IFoo + { } + + public class Base : IFoo + { } + + public abstract class BaseImpl : Base + { } + + public class Foo<T> : BaseImpl, IFoo + { } + + public class FooMap : ClassMap<IFoo> + { } + + public class BaseMap : ClassMap<Base> + { } + + public class BaseImplMap : SubclassMap<BaseImpl> + { } + + public abstract class GenericFooMap<T> : SubclassMap<Foo<T>> + { } + + public class StringFooMap : GenericFooMap<string> + { } + + + public interface IStand + { } + + public class StandAlone : IStand + { } + + public class StandAloneMap : SubclassMap<StandAlone> + { } } } src/FluentNHibernate.Testing/PersistenceModelTests/SeparateSubclassVisitorFixture.cs @@ -63,59 +63,100 @@ namespace FluentNHibernate { if (mapping.Discriminator == null) return new JoinedSubclassMapping(); - + return new SubclassMapping(); } + private bool IsMapped(Type type, IEnumerable<IIndeterminateSubclassMappingProvider> providers) + { + return providers.Any(x => x.EntityType == type); + } + /// <summary> /// Takes a type that represents the level in the class/subclass-hiearchy that we're starting from, the parent, /// this can be a class or subclass; also takes a list of subclass providers. The providers are then iterated /// and added to a dictionary key'd by the types "distance" from the parentType; distance being the number of levels /// between parentType and the subclass-type. + /// + /// By default if the Parent type is an interface the level will always be zero. At this time there is no check for + /// hierarchical interface inheritance. /// </summary> /// <param name="parentType">Starting point, parent type.</param> - /// <param name="providers">List of subclasses</param> + /// <param name="subProviders">List of subclasses</param> /// <returns>Dictionary key'd by the distance from the parentType.</returns> - private IDictionary<int, IList<IIndeterminateSubclassMappingProvider>> SortByDistanceFrom(Type parentType, IEnumerable<IIndeterminateSubclassMappingProvider> providers) + private IDictionary<int, IList<IIndeterminateSubclassMappingProvider>> SortByDistanceFrom(Type parentType, IEnumerable<IIndeterminateSubclassMappingProvider> subProviders) { var arranged = new Dictionary<int, IList<IIndeterminateSubclassMappingProvider>>(); - foreach (var provider in providers) + foreach (var subclassProvider in subProviders) { - var subclassType = provider.EntityType; + var subclassType = subclassProvider.EntityType; var level = 0; - // while not reached parent yet, or have reached the top without finding the parent and parent is an interface and - // the current level implements that interface - while (subclassType.BaseType != parentType || - (subclassType.IsTopLevel() && parentType.IsInterface && subclassType.HasInterface(parentType))) - { - if (IsMapped(subclassType.BaseType, providers)) - level++; - - // reached the top, stop - if (subclassType.IsTopLevel()) - break; + bool implOfParent = parentType.IsInterface + ? DistanceFromParentInterface(parentType, subclassType, ref level) + : DistanceFromParentBase(parentType, subclassType.BaseType, ref level); - subclassType = subclassType.BaseType; - } - - // reached the top and the parent isn't an interface (or the current level doesn't implement it) - if (subclassType.IsTopLevel() && !(parentType.IsInterface && subclassType.HasInterface(parentType))) - continue; + if (!implOfParent) continue; if (!arranged.ContainsKey(level)) arranged[level] = new List<IIndeterminateSubclassMappingProvider>(); - arranged[level].Add(provider); + arranged[level].Add(subclassProvider); } return arranged; } - private bool IsMapped(Type type, IEnumerable<IIndeterminateSubclassMappingProvider> providers) + /// <summary> + /// The evalType starts out as the original subclass. The class hiearchy is only + /// walked if the subclass inherits from a class that is included in the subclassProviders. + /// </summary> + /// <param name="parentType"></param> + /// <param name="evalType"></param> + /// <param name="level"></param> + /// <returns></returns> + private bool DistanceFromParentInterface(Type parentType, Type evalType, ref int level) { - return providers.Any(x => x.EntityType == type); + if (!evalType.HasInterface(parentType)) return false; + + if (!(evalType == typeof(object)) && + IsMapped(evalType.BaseType, subclassProviders)) + { + //Walk the tree if the subclasses base class is also in the subclassProviders + level++; + DistanceFromParentInterface(parentType, evalType.BaseType, ref level); + } + + return true; + } + + /// <summary> + /// The evalType is always one class higher in the hiearchy starting from the original subclass. The class + /// hiearchy is walked until the IsTopLevel (base class is Object) is met. The level is only incremented if + /// the subclass inherits from a class that is also in the subclassProviders. + /// </summary> + /// <param name="parentType"></param> + /// <param name="evalType"></param> + /// <param name="level"></param> + /// <returns></returns> + private bool DistanceFromParentBase(Type parentType, Type evalType, ref int level) + { + var evalImplementsParent = false; + if (evalType == parentType) + evalImplementsParent = true; + + if (!evalImplementsParent && !(evalType == typeof(object))) + { + //If the eval class does not inherit the parent but it is included + //in the subclassprovides, then the original subclass can not inherit + //directly from the parent. + if (IsMapped(evalType, subclassProviders)) + level++; + evalImplementsParent = DistanceFromParentBase(parentType, evalType.BaseType, ref level); + } + + return evalImplementsParent; } } } \ No newline at end of file src/FluentNHibernate/SeparateSubclassVisitor.cs @@ -43,10 +43,5 @@ namespace FluentNHibernate.Utils { return type.GetInterfaces().Contains(interfaceType); } - - public static bool IsTopLevel(this Type type) - { - return type.BaseType == typeof(object); - } } } \ No newline at end of file src/FluentNHibernate/Utils/TypeExtensions.cs e31329f1ecb5c9c6f47f537f97afceea5672a36c Paul Batum paul.batum@gmail.com http://github.com/jagregory/fluent-nhibernate/commit/2fb27381d70b998fb11fe92b44e6b101b4525bff 2fb27381d70b998fb11fe92b44e6b101b4525bff 2009-11-02T16:37:07-08:00 2009-11-02T16:37:07-08:00 Applied patch from rik.bardrof resolving subclassing issue #345 859bb01173efd31dc36bc50e6070472c0a2e93e4 Paul Batum paul.batum@gmail.com