SubclassMapping IIndeterminateSubclassMappingProvider.GetSubclassMapping(SubclassType type)
{
var mapping = new SubclassMapping(type);
GenerateNestedSubclasses(mapping);
attributes.SetDefault(x => x.Type, typeof(T));
attributes.SetDefault(x => x.Name, typeof(T).AssemblyQualifiedName);
attributes.SetDefault(x => x.DiscriminatorValue, typeof(T).Name);
// TODO: un-hardcode this
var key = new KeyMapping();
key.AddDefaultColumn(new ColumnMapping {
Name = typeof(T).BaseType.Name + "_id"
});
attributes.SetDefault(x => x.TableName, GetDefaultTableName());
attributes.SetDefault(x => x.Key, key);
// TODO: this is nasty, we should find a better way
mapping.OverrideAttributes(attributes.CloneInner());
foreach (var join in joins)
{
mapping.AddJoin(join);
}
foreach (var property in properties)
{
mapping.AddProperty(property.GetPropertyMapping());
}
foreach (var component in components)
{
mapping.AddComponent(component.GetComponentMapping());
}
foreach (var oneToOne in oneToOnes)
{
mapping.AddOneToOne(oneToOne.GetOneToOneMapping());
}
foreach (var collection in collections)
{
mapping.AddCollection(collection.GetCollectionMapping());
}
foreach (var reference in references)
{
mapping.AddReference(reference.GetManyToOneMapping());
}
foreach (var any in anys)
{
mapping.AddAny(any.GetAnyMapping());
}
return(mapping.DeepClone());
}
public void ShouldWriteJoinedSubclassForJoinedSubclassMapping()
{
var mapping = new SubclassMapping(SubclassType.JoinedSubclass);
writer.VerifyXml(mapping)
.RootElement.HasName("joined-subclass");
}
public void ShouldWriteJoinedSubclassForJoinedSubclassMapping()
{
var mapping = new SubclassMapping(SubclassType.JoinedSubclass);
writer.VerifyXml(mapping)
.RootElement.HasName("joined-subclass");
}
public void ShouldWriteSubclassForSubclassMapping()
{
var mapping = new SubclassMapping();
writer.VerifyXml(mapping)
.RootElement.HasName("subclass");
}
public override void ProcessSubclass(SubclassMapping subclassMapping)
{
var conventions = finder.Find <ISubclassConvention>();
Apply <ISubclassInspector, ISubclassInstance>(conventions,
new SubclassInstance(subclassMapping));
}
public void Can_add_subclass()
{
var joinedSubclass = new SubclassMapping(SubclassType.JoinedSubclass);
mapping.AddSubclass(joinedSubclass);
mapping.Subclasses.ShouldContain(joinedSubclass);
}
public void ShouldWriteSubclassForSubclassMapping()
{
var mapping = new SubclassMapping();
writer.VerifyXml(mapping)
.RootElement.HasName("subclass");
}
public override void Visit(SubclassMapping subclassMapping)
{
var writer = serviceLocator.GetWriter <SubclassMapping>();
var subclassXml = writer.Write(subclassMapping);
document.ImportAndAppendChild(subclassXml);
}
private void MapInheritanceTree(Type classType, ClassMappingBase mapping, IList<Member> mappedMembers)
{
var discriminatorSet = HasDiscriminator(mapping);
var isDiscriminated = cfg.IsDiscriminated(classType) || discriminatorSet;
var mappingTypesWithLogicalParents = GetMappingTypesWithLogicalParents();
foreach (var inheritedClass in mappingTypesWithLogicalParents
.Where(x => x.Value != null && x.Value.Type == classType)
.Select(x => x.Key))
{
var tempMapping = mapping as ClassMapping;
var tempIsNull = tempMapping == null;
if (isDiscriminated && !discriminatorSet && !tempIsNull)
{
var discriminatorColumn = cfg.GetDiscriminatorColumn(classType);
var discriminator = new DiscriminatorMapping
{
ContainingEntityType = classType,
Type = new TypeReference(typeof(string))
};
discriminator.AddDefaultColumn(new ColumnMapping { Name = discriminatorColumn });
tempMapping.Discriminator = discriminator;
discriminatorSet = true;
}
SubclassMapping subclassMapping;
if(!tempIsNull && tempMapping.IsUnionSubclass)
{
subclassMapping = new SubclassMapping(SubclassType.UnionSubclass)
{
Type = inheritedClass.Type
};
}
else if(!isDiscriminated)
{
subclassMapping = new SubclassMapping(SubclassType.JoinedSubclass)
{
Type = inheritedClass.Type
};
subclassMapping.Key = new KeyMapping();
subclassMapping.Key.AddDefaultColumn(new ColumnMapping { Name = mapping.Type.Name + "_id" });
}
else
subclassMapping = new SubclassMapping(SubclassType.Subclass)
{
Type = inheritedClass.Type
};
// track separate set of properties for each sub-tree within inheritance hierarchy
var subclassMembers = new List<Member>(mappedMembers);
MapSubclass(subclassMembers, subclassMapping, inheritedClass);
mapping.AddSubclass(subclassMapping);
MergeMap(inheritedClass.Type, subclassMapping, subclassMembers);
}
}
private void MapInheritanceTree(Type classType, ClassMappingBase mapping, IList <Member> mappedMembers)
{
var discriminatorSet = HasDiscriminator(mapping);
var isDiscriminated = cfg.IsDiscriminated(classType) || discriminatorSet;
var mappingTypesWithLogicalParents = GetMappingTypesWithLogicalParents();
foreach (var inheritedClass in mappingTypesWithLogicalParents
.Where(x => x.Value != null && x.Value.Type == classType)
.Select(x => x.Key))
{
var tempMapping = mapping as ClassMapping;
var tempIsNull = tempMapping == null;
if (isDiscriminated && !discriminatorSet && !tempIsNull)
{
var discriminatorColumn = cfg.GetDiscriminatorColumn(classType);
var discriminator = new DiscriminatorMapping
{
ContainingEntityType = classType,
};
discriminator.Set(x => x.Type, Layer.Defaults, new TypeReference(typeof(string)));
var columnMapping = new ColumnMapping();
columnMapping.Set(x => x.Name, Layer.Defaults, discriminatorColumn);
discriminator.AddColumn(Layer.Defaults, columnMapping);
tempMapping.Set(x => x.Discriminator, Layer.Defaults, discriminator);
discriminatorSet = true;
}
SubclassMapping subclassMapping;
var tempSubClassMap = mapping as SubclassMapping;
if (!tempIsNull && tempMapping.IsUnionSubclass || tempSubClassMap != null && tempSubClassMap.SubclassType == SubclassType.UnionSubclass)
{
subclassMapping = new SubclassMapping(SubclassType.UnionSubclass);
subclassMapping.Set(x => x.Type, Layer.Defaults, inheritedClass.Type);
}
else if (isDiscriminated || tempSubClassMap != null && tempSubClassMap.SubclassType == SubclassType.Subclass)
{
subclassMapping = new SubclassMapping(SubclassType.Subclass);
subclassMapping.Set(x => x.Type, Layer.Defaults, inheritedClass.Type);
}
else
{
subclassMapping = new SubclassMapping(SubclassType.JoinedSubclass);
subclassMapping.Set(x => x.Type, Layer.Defaults, inheritedClass.Type);
subclassMapping.Set(x => x.Key, Layer.Defaults, new KeyMapping());
var columnMapping = new ColumnMapping();
columnMapping.Set(x => x.Name, Layer.Defaults, mapping.Type.Name + "_id");
subclassMapping.Key.AddColumn(Layer.Defaults, columnMapping);
}
// track separate set of properties for each sub-tree within inheritance hierarchy
var subclassMembers = new List <Member>(mappedMembers);
MapSubclass(subclassMembers, subclassMapping, inheritedClass);
mapping.AddSubclass(subclassMapping);
MergeMap(inheritedClass.Type, subclassMapping, subclassMembers);
}
}
private void MapSubclass(IList <Member> mappedMembers, SubclassMapping subclass, AutoMapType inheritedClass)
{
subclass.Name = inheritedClass.Type.AssemblyQualifiedName;
subclass.Type = inheritedClass.Type;
ApplyOverrides(inheritedClass.Type, mappedMembers, subclass);
ProcessClass(subclass, inheritedClass.Type, mappedMembers);
inheritedClass.IsMapped = true;
}
private void MapSubclass(IList <Member> mappedMembers, SubclassMapping subclass, AutoMapType inheritedClass)
{
subclass.Set(x => x.Name, Layer.Defaults, inheritedClass.Type.AssemblyQualifiedName);
subclass.Set(x => x.Type, Layer.Defaults, inheritedClass.Type);
ApplyOverrides(inheritedClass.Type, mappedMembers, subclass);
ProcessClass(subclass, inheritedClass.Type, mappedMembers);
inheritedClass.IsMapped = true;
}
public void ShouldWriteSet()
{
var mapping = new SubclassMapping(SubclassType.Subclass);
mapping.AddCollection(CollectionMapping.Set());
writer.VerifyXml(mapping)
.Element("set").Exists();
}
public void ShouldWriteComponents()
{
var mapping = new SubclassMapping(SubclassType.Subclass);
mapping.AddComponent(new ComponentMapping(ComponentType.Component));
writer.VerifyXml(mapping)
.Element("component").Exists();
}
public void ShouldWriteMap()
{
var mapping = new SubclassMapping(SubclassType.Subclass);
mapping.AddCollection(new MapMapping());
writer.VerifyXml(mapping)
.Element("map").Exists();
}
public override void ProcessSubclass(SubclassMapping mapping)
{
var subclasses = FindClosestSubclasses(mapping.Type);
foreach (var provider in subclasses)
mapping.AddSubclass(provider.GetSubclassMapping(new SubclassMapping()));
base.ProcessSubclass(mapping);
}
public void ShouldWriteOneToOnes()
{
var mapping = new SubclassMapping();
mapping.AddOneToOne(new OneToOneMapping());
writer.VerifyXml(mapping)
.Element("one-to-one").Exists();
}
private void MapInheritanceTree(Type classType, ClassMappingBase mapping, IList <string> mappedProperties)
{
var discriminatorSet = false;
var isDiscriminated = expressions.IsDiscriminated(classType);
foreach (var inheritedClass in mappingTypes.Where(q =>
q.Type.BaseType == classType &&
!expressions.IsConcreteBaseType(q.Type.BaseType)))
{
if (isDiscriminated && !discriminatorSet && mapping is ClassMapping)
{
var discriminatorColumn = expressions.DiscriminatorColumn(classType);
var discriminator = new DiscriminatorMapping
{
ContainingEntityType = classType,
Type = new TypeReference(typeof(string))
};
discriminator.AddDefaultColumn(new ColumnMapping {
Name = discriminatorColumn
});
((ClassMapping)mapping).Discriminator = discriminator;
discriminatorSet = true;
}
ISubclassMapping subclassMapping;
var subclassStrategy = expressions.SubclassStrategy(classType);
if (subclassStrategy == SubclassStrategy.JoinedSubclass)
{
// TODO: This id name should be removed. Ideally it needs to be set by a
// default and be overridable by a convention (preferably the ForeignKey convention
// that already exists)
var subclass = new JoinedSubclassMapping
{
Type = inheritedClass.Type
};
subclass.Key = new KeyMapping();
subclass.Key.AddDefaultColumn(new ColumnMapping {
Name = mapping.Type.Name + "_id"
});
subclassMapping = subclass;
}
else
{
subclassMapping = new SubclassMapping();
}
MapSubclass(mappedProperties, subclassMapping, inheritedClass);
mapping.AddSubclass(subclassMapping);
MergeMap(inheritedClass.Type, (ClassMappingBase)subclassMapping, mappedProperties);
}
}
public void ShouldWriteComponents()
{
var mapping = new SubclassMapping();
mapping.AddComponent(new ComponentMapping());
writer.VerifyXml(mapping)
.Element("component").Exists();
}
public void ShouldWriteBag()
{
var mapping = new SubclassMapping();
mapping.AddCollection(new BagMapping());
writer.VerifyXml(mapping)
.Element("bag").Exists();
}
public void ShouldWriteAny()
{
var mapping = new SubclassMapping();
mapping.AddAny(new AnyMapping());
writer.VerifyXml(mapping)
.Element("any").Exists();
}
void GenerateNestedSubclasses(SubclassMapping mapping)
{
foreach (var subclassType in indetermineateSubclasses.Keys)
{
var subclassMapping = indetermineateSubclasses[subclassType].GetSubclassMapping(mapping.SubclassType);
mapping.AddSubclass(subclassMapping);
}
}
public void ShouldWriteJoin()
{
var mapping = new SubclassMapping();
mapping.AddJoin(new JoinMapping());
writer.VerifyXml(mapping)
.Element("join").Exists();
}
public void ShouldWriteProperties()
{
var mapping = new SubclassMapping();
mapping.AddProperty(new PropertyMapping());
writer.VerifyXml(mapping)
.Element("property").Exists();
}
public void ShouldWriteAny()
{
var mapping = new SubclassMapping();
mapping.AddAny(new AnyMapping());
writer.VerifyXml(mapping)
.Element("any").Exists();
}
public void ShouldWriteSubclass()
{
var mapping = new SubclassMapping(SubclassType.JoinedSubclass);
mapping.AddSubclass(new SubclassMapping(SubclassType.JoinedSubclass));
writer.VerifyXml(mapping)
.Element("joined-subclass").Exists();
}
public void ShouldWriteBag()
{
var mapping = new SubclassMapping();
mapping.AddCollection(new BagMapping());
writer.VerifyXml(mapping)
.Element("bag").Exists();
}
public void ShouldWriteList()
{
var mapping = new SubclassMapping();
mapping.AddCollection(new ListMapping());
writer.VerifyXml(mapping)
.Element("list").Exists();
}
public void ShouldWriteBag()
{
var mapping = new SubclassMapping(SubclassType.JoinedSubclass);
mapping.AddCollection(CollectionMapping.Bag());
writer.VerifyXml(mapping)
.Element("bag").Exists();
}
public void ShouldWriteDynamicComponents()
{
var mapping = new SubclassMapping(SubclassType.JoinedSubclass);
mapping.AddComponent(new ComponentMapping(ComponentType.DynamicComponent));
writer.VerifyXml(mapping)
.Element("dynamic-component").Exists();
}
public void ShouldWriteDynamicComponents()
{
var mapping = new SubclassMapping();
mapping.AddComponent(new DynamicComponentMapping());
writer.VerifyXml(mapping)
.Element("dynamic-component").Exists();
}
public void ShouldWriteManyToOnes()
{
var mapping = new SubclassMapping();
mapping.AddReference(new ManyToOneMapping());
writer.VerifyXml(mapping)
.Element("many-to-one").Exists();
}
public void ShouldWriteSubclass()
{
var mapping = new SubclassMapping();
mapping.AddSubclass(new SubclassMapping());
writer.VerifyXml(mapping)
.Element("subclass").Exists();
}
public static void PropertyEnum <TObj, TEnum>(this SubclassMapping <TObj> mapper, Expression <Func <TObj, TEnum> > func, string columnName)
where TObj : Entity
where TEnum : struct
{
mapper.Property(func, attr =>
{
attr.Type <EnumStringType <TEnum> >();
attr.Column(columnName);
});
}
public void Should_write_the_collections()
{
var subclassMapping = new SubclassMapping();
subclassMapping.AddCollection(new BagMapping());
_mocker.Get<IHbmWriter<ICollectionMapping>>()
.Expect(x => x.Write(subclassMapping.Collections.First())).Return(new HbmBag());
_subclassWriter.VerifyXml(subclassMapping)
.Element("bag").Exists();
}
public void Should_write_the_components()
{
var classMapping = new SubclassMapping();
classMapping.AddComponent(new ComponentMapping());
_mocker.Get<IHbmWriter<ComponentMapping>>()
.Expect(x => x.Write(classMapping.Components.First())).Return(new HbmComponent());
_subclassWriter.VerifyXml(classMapping)
.Element("component").Exists();
}
public override void ProcessSubclass(SubclassMapping mapping)
{
var subclasses = subclassProviders
.Select(x => x.GetSubclassMapping(new SubclassMapping()))
.Where(x => x.Type.BaseType == mapping.Type);
foreach (var subclass in subclasses)
mapping.AddSubclass(subclass);
base.ProcessSubclass(mapping);
}
public void Should_write_multiple_nestings_of_subclasses()
{
var subclassMapping = new SubclassMapping();
subclassMapping.AddSubclass(new SubclassMapping { Name = "Child" });
subclassMapping.Subclasses.First().AddSubclass(new SubclassMapping { Name = "Grandchild" });
_subclassWriter.VerifyXml(subclassMapping)
.Element("subclass").Exists().HasAttribute("name", "Child")
.Element("subclass").Exists().HasAttribute("name", "Grandchild");
}
public override void ProcessSubclass(SubclassMapping mapping)
{
var subclasses = FindClosestSubclasses(mapping.Type);
foreach (var provider in subclasses)
{
mapping.AddSubclass(provider.GetSubclassMapping(mapping.SubclassType));
}
base.ProcessSubclass(mapping);
}
public void Can_map_property()
{
var mapping = new SubclassMapping();
var subclassPart = new SubclassPart<SalaryEmployee>(mapping);
subclassPart.Map(x => x.Salary);
var salaryProperty = mapping.Properties.FirstOrDefault();
salaryProperty.ShouldNotBeNull();
salaryProperty.MappedMember.ShouldEqual(ReflectionHelper.GetMember<SalaryEmployee>(x => x.Salary));
}
SubclassMapping ISubclassMappingProvider.GetSubclassMapping()
{
var mapping = new SubclassMapping(SubclassType.JoinedSubclass, attributes.CloneInner());
mapping.Key = new KeyMapping {
ContainingEntityType = typeof(TSubclass)
};
mapping.Name = typeof(TSubclass).AssemblyQualifiedName;
mapping.Type = typeof(TSubclass);
foreach (var column in columns)
{
mapping.Key.AddColumn(column);
}
foreach (var property in properties)
{
mapping.AddProperty(property.GetPropertyMapping());
}
foreach (var component in components)
{
mapping.AddComponent(component.GetComponentMapping());
}
foreach (var oneToOne in oneToOnes)
{
mapping.AddOneToOne(oneToOne.GetOneToOneMapping());
}
foreach (var collection in collections)
{
mapping.AddCollection(collection.GetCollectionMapping());
}
foreach (var reference in references)
{
mapping.AddReference(reference.GetManyToOneMapping());
}
foreach (var any in anys)
{
mapping.AddAny(any.GetAnyMapping());
}
return(mapping);
}
SubclassMapping ISubclassMappingProvider.GetSubclassMapping()
{
var mapping = new SubclassMapping(SubclassType.JoinedSubclass, attributes.Clone());
mapping.Set(x => x.Key, Layer.Defaults, new KeyMapping {
ContainingEntityType = typeof(TSubclass)
});
mapping.Set(x => x.Name, Layer.Defaults, typeof(TSubclass).AssemblyQualifiedName);
mapping.Set(x => x.Type, Layer.Defaults, typeof(TSubclass));
foreach (var column in columns)
{
mapping.Key.AddColumn(Layer.Defaults, column);
}
foreach (var property in providers.Properties)
{
mapping.AddProperty(property.GetPropertyMapping());
}
foreach (var component in providers.Components)
{
mapping.AddComponent(component.GetComponentMapping());
}
foreach (var oneToOne in providers.OneToOnes)
{
mapping.AddOneToOne(oneToOne.GetOneToOneMapping());
}
foreach (var collection in providers.Collections)
{
mapping.AddCollection(collection.GetCollectionMapping());
}
foreach (var reference in providers.References)
{
mapping.AddReference(reference.GetManyToOneMapping());
}
foreach (var any in providers.Anys)
{
mapping.AddAny(any.GetAnyMapping());
}
return(mapping);
}
private void MapInheritanceTree(Type classType, ClassMappingBase mapping, IList<Member> mappedMembers)
{
var discriminatorSet = false;
var isDiscriminated = cfg.IsDiscriminated(classType);
foreach (var inheritedClass in mappingTypes.Where(q =>
q.Type.BaseType == classType &&
!cfg.IsConcreteBaseType(q.Type.BaseType)))
{
if (isDiscriminated && !discriminatorSet && mapping is ClassMapping)
{
var discriminatorColumn = cfg.GetDiscriminatorColumn(classType);
var discriminator = new DiscriminatorMapping
{
ContainingEntityType = classType,
Type = new TypeReference(typeof(string))
};
discriminator.AddDefaultColumn(new ColumnMapping { Name = discriminatorColumn });
((ClassMapping)mapping).Discriminator = discriminator;
discriminatorSet = true;
}
SubclassMapping subclassMapping;
var subclassStrategy = cfg.GetSubclassStrategy(classType);
if (subclassStrategy == SubclassStrategy.JoinedSubclass)
{
subclassMapping = new SubclassMapping(SubclassType.JoinedSubclass);
subclassMapping.Key = new KeyMapping();
subclassMapping.Key.AddDefaultColumn(new ColumnMapping { Name = mapping.Type.Name + "_id" });
}
else
subclassMapping = new SubclassMapping(SubclassType.Subclass);
// track separate set of properties for each sub-tree within inheritance hierarchy
var subclassMembers = new List<Member>(mappedMembers);
MapSubclass(subclassMembers, subclassMapping, inheritedClass);
mapping.AddSubclass(subclassMapping);
MergeMap(inheritedClass.Type, subclassMapping, subclassMembers);
}
}
public void ShouldWriteBag()
{
var mapping = new SubclassMapping(SubclassType.JoinedSubclass);
mapping.AddCollection(CollectionMapping.Bag());
writer.VerifyXml(mapping)
.Element("bag").Exists();
}
public void ShouldWriteDynamicComponents()
{
var mapping = new SubclassMapping(SubclassType.JoinedSubclass);
mapping.AddComponent(new ComponentMapping(ComponentType.DynamicComponent));
writer.VerifyXml(mapping)
.Element("dynamic-component").Exists();
}
public void ShouldWriteOneToOnes()
{
var mapping = new SubclassMapping(SubclassType.JoinedSubclass);
mapping.AddOneToOne(new OneToOneMapping());
writer.VerifyXml(mapping)
.Element("one-to-one").Exists();
}
public void ShouldWriteManyToOnes()
{
var mapping = new SubclassMapping(SubclassType.JoinedSubclass);
mapping.AddReference(new ManyToOneMapping());
writer.VerifyXml(mapping)
.Element("many-to-one").Exists();
}
public void ShouldWriteProperties()
{
var mapping = new SubclassMapping(SubclassType.JoinedSubclass);
mapping.AddProperty(new PropertyMapping());
writer.VerifyXml(mapping)
.Element("property").Exists();
}
public SubclassInspector(SubclassMapping mapping)
{
this.mapping = mapping;
mappedProperties.Map(x => x.LazyLoad, x => x.Lazy);
}
public override void ProcessSubclass(SubclassMapping subclassMapping)
{
ProcessClassBase(subclassMapping);
}
public virtual void Visit(SubclassMapping subclassMapping)
{
}
private void MapSubclass(IList<Member> mappedMembers, SubclassMapping subclass, AutoMapType inheritedClass)
{
subclass.Name = inheritedClass.Type.AssemblyQualifiedName;
subclass.Type = inheritedClass.Type;
ApplyOverrides(inheritedClass.Type, mappedMembers, subclass);
ProcessClass(subclass, inheritedClass.Type, mappedMembers);
inheritedClass.IsMapped = true;
}
public void ShouldWriteSubclass()
{
var mapping = new SubclassMapping();
mapping.AddSubclass(new SubclassMapping());
writer.VerifyXml(mapping)
.Element("subclass").Exists();
}
public override void Visit(SubclassMapping subclassMapping)
{
subclassMapping.AcceptVisitor(this);
}
public void ShouldWriteSubclass()
{
var mapping = new SubclassMapping(SubclassType.JoinedSubclass);
mapping.AddSubclass(new SubclassMapping(SubclassType.JoinedSubclass));
writer.VerifyXml(mapping)
.Element("joined-subclass").Exists();
}
public void Should_apply_to_subclass_mapping()
{
var subclassMapping = new SubclassMapping();
subclassMapping.Type = typeof(Album);
_namingConvention.ProcessSubclass(subclassMapping);
subclassMapping.Name.ShouldEqual(subclassMapping.Type.AssemblyQualifiedName);
}
public virtual void ProcessSubclass(SubclassMapping subclassMapping)
{
}
public void ShouldWriteList()
{
var mapping = new SubclassMapping(SubclassType.JoinedSubclass);
mapping.AddCollection(new ListMapping());
writer.VerifyXml(mapping)
.Element("list").Exists();
}
private void MapSubclass(IList<Member> mappedMembers, SubclassMapping subclass, AutoMapType inheritedClass)
{
subclass.Set(x => x.Name, Layer.Defaults, inheritedClass.Type.AssemblyQualifiedName);
subclass.Set(x => x.Type, Layer.Defaults, inheritedClass.Type);
ApplyOverrides(inheritedClass.Type, mappedMembers, subclass);
ProcessClass(subclass, inheritedClass.Type, mappedMembers);
inheritedClass.IsMapped = true;
}
private void MapInheritanceTree(Type classType, ClassMappingBase mapping, IList<string> mappedProperties)
{
var discriminatorSet = false;
var isDiscriminated = expressions.IsDiscriminated(classType);
foreach (var inheritedClass in mappingTypes.Where(q =>
q.Type.BaseType == classType &&
!expressions.IsConcreteBaseType(q.Type.BaseType)))
{
if (isDiscriminated && !discriminatorSet && mapping is ClassMapping)
{
var discriminatorColumn = expressions.DiscriminatorColumn(classType);
var discriminator = new DiscriminatorMapping
{
ContainingEntityType = classType,
Type = new TypeReference(typeof(string))
};
discriminator.AddDefaultColumn(new ColumnMapping { Name = discriminatorColumn });
((ClassMapping)mapping).Discriminator = discriminator;
discriminatorSet = true;
}
ISubclassMapping subclassMapping;
var subclassStrategy = expressions.SubclassStrategy(classType);
if (subclassStrategy == SubclassStrategy.JoinedSubclass)
{
// TODO: This id name should be removed. Ideally it needs to be set by a
// default and be overridable by a convention (preferably the ForeignKey convention
// that already exists)
var subclass = new JoinedSubclassMapping
{
Type = inheritedClass.Type
};
subclass.Key = new KeyMapping();
subclass.Key.AddDefaultColumn(new ColumnMapping { Name = mapping.Type.Name + "_id" });
subclassMapping = subclass;
}
else
subclassMapping = new SubclassMapping();
MapSubclass(mappedProperties, subclassMapping, inheritedClass);
mapping.AddSubclass(subclassMapping);
MergeMap(inheritedClass.Type, (ClassMappingBase)subclassMapping, mappedProperties);
}
}
