Dictionary <AutoMapType, AutoMapType> GetMappingTypesWithLogicalParents()
{
var excludedTypes = mappingTypes
.Where(x => cfg.IsConcreteBaseType(x.Type.BaseType))
.ToArray();
var availableTypes = mappingTypes.Except(excludedTypes).ToDictionary(x => x.Type);
var mappingTypesWithLogicalParents = new Dictionary <AutoMapType, AutoMapType>();
foreach (var type in availableTypes)
{
mappingTypesWithLogicalParents.Add(type.Value, GetLogicalParent(type.Key, availableTypes));
}
return(mappingTypesWithLogicalParents);
}
private bool ShouldMapParent(Type type)
{
return(ShouldMap(type.BaseType) && !cfg.IsConcreteBaseType(type.BaseType));
}
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));
}