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 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))
{
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;
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);
}
}
bool HasDiscriminator(ClassMappingBase mapping)
{
if (mapping is ClassMapping && ((ClassMapping)mapping).Discriminator != null)
{
return(true);
}
return(false);
}
Dictionary <AutoMapType, AutoMapType> GetMappingTypesWithLogicalParents()
{
var excludedTypes = mappingTypes
.Where(x => cfg.IsConcreteBaseType(x.Type.BaseType))
.ToArray();
var availableTypes = mappingTypes.Except(excludedTypes);
var mappingTypesWithLogicalParents = new Dictionary <AutoMapType, AutoMapType>();
foreach (var type in availableTypes)
{
mappingTypesWithLogicalParents.Add(type, GetLogicalParent(type.Type, availableTypes));
}
return(mappingTypesWithLogicalParents);
}
AutoMapType GetLogicalParent(Type type, IEnumerable <AutoMapType> availableTypes)
{
if (type.BaseType == typeof(object) || type.BaseType == null)
{
return(null);
}
var baseType = availableTypes.FirstOrDefault(x => x.Type == type.BaseType);
if (baseType != null)
{
return(baseType);
}
return(GetLogicalParent(type.BaseType, availableTypes));
}