public void BuildTypeDiscriminatorMap(TypeDef typeDef, TypeInfo typeInfo)
{
if (typeDef.TypeDiscriminatorValue != null)
{
var targetField = typeInfo.Fields.SingleOrDefault(f => f.IsTypeDiscriminator && f.Parent == null);
if (targetField == null)
{
throw new DomainBuilderException(string.Format(Strings.ExTypeDiscriminatorIsNotFoundForXType, typeInfo.Name));
}
if (targetField.IsEntity)
{
targetField = targetField.Fields.First();
targetField.IsTypeDiscriminator = true;
}
typeInfo.TypeDiscriminatorValue =
ValueTypeBuilder.AdjustValue(targetField, targetField.ValueType, typeDef.TypeDiscriminatorValue);
typeInfo.Hierarchy.TypeDiscriminatorMap.RegisterTypeMapping(typeInfo, typeInfo.TypeDiscriminatorValue);
}
if (typeDef.IsDefaultTypeInHierarchy)
{
typeInfo.Hierarchy.TypeDiscriminatorMap.RegisterDefaultType(typeInfo);
}
}
private void ProcessDefault(FieldDef fieldDef, FieldAttribute attribute)
{
var defaultValue = attribute.DefaultValue;
if (defaultValue != null)
{
fieldDef.DefaultValue = ValueTypeBuilder.AdjustValue(fieldDef, defaultValue);
}
}
private FieldInfo BuildDeclaredField(TypeInfo type, FieldDef fieldDef)
{
BuildLog.Info(Strings.LogBuildingDeclaredFieldXY, type.Name, fieldDef.Name);
var fieldInfo = new FieldInfo(type, fieldDef.Attributes)
{
UnderlyingProperty = fieldDef.UnderlyingProperty,
Name = fieldDef.Name,
OriginalName = fieldDef.Name,
MappingName = fieldDef.MappingName,
ValueType = fieldDef.ValueType,
ItemType = fieldDef.ItemType,
Length = fieldDef.Length,
Scale = fieldDef.Scale,
Precision = fieldDef.Precision,
Validators = fieldDef.Validators,
};
if (fieldInfo.IsStructure && DeclaresOnValidate(fieldInfo.ValueType))
{
fieldInfo.Validators.Add(new StructureFieldValidator());
}
if (fieldInfo.IsEntitySet && DeclaresOnValidate(fieldInfo.ValueType))
{
fieldInfo.Validators.Add(new EntitySetFieldValidator());
}
type.Fields.Add(fieldInfo);
if (fieldInfo.IsEntitySet)
{
AssociationBuilder.BuildAssociation(context, fieldDef, fieldInfo);
return(fieldInfo);
}
if (fieldInfo.IsEntity)
{
var fields = context.Model.Types[fieldInfo.ValueType].Fields.Where(f => f.IsPrimaryKey);
// Adjusting default value if any
if (fields.Count() == 1 && fieldDef.DefaultValue != null)
{
fieldInfo.DefaultValue =
ValueTypeBuilder.AdjustValue(fieldInfo, fields.First().ValueType, fieldDef.DefaultValue);
}
BuildNestedFields(null, fieldInfo, fields);
if (!IsAuxiliaryType(type))
{
AssociationBuilder.BuildAssociation(context, fieldDef, fieldInfo);
if (type.IsStructure)
{
fieldInfo.Associations.ForEach(a => context.DiscardedAssociations.Add(a));
}
}
// Adjusting type discriminator field for references
if (fieldDef.IsTypeDiscriminator)
{
type.Hierarchy.TypeDiscriminatorMap.Field = fieldInfo.Fields.First();
}
}
if (fieldInfo.IsStructure)
{
BuildNestedFields(null, fieldInfo, context.Model.Types[fieldInfo.ValueType].Fields);
var structureFullTextIndex = context.ModelDef.FullTextIndexes.TryGetValue(fieldInfo.ValueType);
if (structureFullTextIndex != null)
{
var hierarchyTypeInfo = context.Model.Types[fieldInfo.DeclaringType.UnderlyingType];
var structureTypeInfo = context.Model.Types[fieldInfo.ValueType];
var currentIndex = context.ModelDef.FullTextIndexes.TryGetValue(hierarchyTypeInfo.UnderlyingType);
if (currentIndex == null)
{
currentIndex = new FullTextIndexDef(context.ModelDef.Types.TryGetValue(type.UnderlyingType));
context.ModelDef.FullTextIndexes.Add(currentIndex);
}
currentIndex.Fields.AddRange(structureFullTextIndex.Fields
.Select(f => new {
fieldInfo.DeclaringType
.StructureFieldMapping[new Pair <FieldInfo>(fieldInfo, structureTypeInfo.Fields[f.Name])].Name,
f.IsAnalyzed,
f.Configuration,
f.TypeFieldName
})
.Select(g => new FullTextFieldDef(g.Name, g.IsAnalyzed)
{
Configuration = g.Configuration, TypeFieldName = g.TypeFieldName
}));
}
}
if (fieldInfo.IsPrimitive)
{
fieldInfo.DefaultValue = fieldDef.DefaultValue;
fieldInfo.DefaultSqlExpression = fieldDef.DefaultSqlExpression;
fieldInfo.Column = BuildDeclaredColumn(fieldInfo);
if (fieldDef.IsTypeDiscriminator)
{
type.Hierarchy.TypeDiscriminatorMap.Field = fieldInfo;
}
}
return(fieldInfo);
}