// We get here when we are inside x:ClassAttributes or x:Property.Attributes. We expect the first element to be the Attribute SO.
internal static AttributeData LoadAttributeData(XamlReader reader, NamespaceTable namespaceTable, string rootNamespace)
{
AttributeData attributeData = null;
reader.Read();
if (reader.NodeType == XamlNodeType.StartObject)
{
attributeData = new AttributeData { Type = reader.Type };
bool readNext = false;
while (readNext || reader.Read())
{
namespaceTable.ManageNamespace(reader);
readNext = false;
if (reader.NodeType == XamlNodeType.StartMember)
{
if (reader.Member == XamlLanguage.Arguments)
{
foreach (AttributeParameterData parameterData in ReadParameters(reader.ReadSubtree(), namespaceTable, rootNamespace))
{
attributeData.Parameters.Add(parameterData);
}
readNext = true;
}
else if (!reader.Member.IsDirective)
{
KeyValuePair<string, AttributeParameterData> propertyInfo = ReadAttributeProperty(reader.ReadSubtree(), namespaceTable, rootNamespace);
attributeData.Properties.Add(propertyInfo.Key, propertyInfo.Value);
readNext = true;
}
}
}
}
return attributeData;
}
public ClassImporter(string xamlFileName, string localAssemblyName, string rootNamespace)
{
this.xamlFileName = xamlFileName;
this.localAssemblyName = localAssemblyName;
this.rootNamespace = rootNamespace;
this.DefaultClassIsPublic = true;
this.DefaultFieldVisibility = MemberVisibility.Assembly;
this.namespaceTable = new NamespaceTable(localAssemblyName);
}
// Read the Property on the attribute.
private static KeyValuePair<string, AttributeParameterData> ReadAttributeProperty(XamlReader reader, NamespaceTable namespaceTable, string rootNamespace)
{
reader.Read();
Fx.Assert(reader.Member != null, "Member element should not be null");
XamlMember member = reader.Member;
AttributeParameterData propertyInfo = new AttributeParameterData();
if (member.Type != null && !member.Type.IsUnknown)
{
propertyInfo.Type = member.Type;
}
ReadParamInfo(reader, member.Type, namespaceTable, rootNamespace, propertyInfo);
return new KeyValuePair<string, AttributeParameterData>(member.Name, propertyInfo);
}
// Parses a XAML QName to a CLR Type Name (and the corresponding ROL type, if available)
private static Tuple<string, Type> ParseParameterValueTypeName(string paramValue, string rootNamespace, XamlSchemaContext schemaContext, NamespaceTable namespaceTable)
{
XamlType xamlType = XamlBuildTaskServices.GetXamlTypeFromString(paramValue, namespaceTable, schemaContext);
string clrTypeName;
if (!XamlBuildTaskServices.TryGetClrTypeName(xamlType, rootNamespace, out clrTypeName))
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.TypeNameUnknown(XamlBuildTaskServices.GetFullTypeName(xamlType))));
}
return Tuple.Create(clrTypeName, xamlType.UnderlyingType);
}
// Get the paramter value. If the value is enclosed inside nodes of the type, then get the parameter type as well.
// Else infer the type from the type of the property.
private static void GetParamValueType(XamlReader reader, XamlType type, NamespaceTable namespaceTable, string rootNamespace, out string paramValue, out XamlType paramType, out Object paramObj)
{
paramValue = String.Empty;
paramType = type;
paramObj = null;
while (reader.Read())
{
if (reader.NodeType == XamlNodeType.Value)
{
if (paramType != null && paramType.UnderlyingType != null)
{
if (!IsSupportedParameterType(paramType.UnderlyingType) || paramType.UnderlyingType.IsArray)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.AttributeParamTypeNotSupported(paramType.UnderlyingType.FullName)));
}
paramValue = reader.Value as string;
if (typeof(Type).IsAssignableFrom(paramType.UnderlyingType))
{
Tuple<string, Type> result = ParseParameterValueTypeName(paramValue, rootNamespace, reader.SchemaContext, namespaceTable);
paramValue = result.Item1;
paramObj = result.Item2;
}
else
{
paramObj = ParseParameterValue(ref paramValue, paramType);
}
}
else
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.AttributeParameterTypeUnknown(reader.Value as string)));
}
}
else if (reader.NodeType == XamlNodeType.StartObject)
{
if (reader.Type == XamlLanguage.Null)
{
paramValue = null;
paramType = null;
}
else if (reader.Type == XamlLanguage.Type)
{
paramType = reader.SchemaContext.GetXamlType(typeof(Type));
}
else
{
paramType = reader.Type;
}
}
}
}
// Read the actual parameter info, i.e. the type of the paramter and its value.
// The first element could be a V or an SO.
private static void ReadParamInfo(XamlReader reader, XamlType type, NamespaceTable namespaceTable, string rootNamespace, AttributeParameterData paramInfo)
{
reader.Read();
bool readNext = false;
do
{
readNext = false;
if (reader.NodeType == XamlNodeType.StartObject && reader.Type == XamlLanguage.Array)
{
paramInfo.IsArray = true;
XamlReader xamlArrayReader = reader.ReadSubtree();
xamlArrayReader.Read();
while (readNext || xamlArrayReader.Read())
{
readNext = false;
if (xamlArrayReader.NodeType == XamlNodeType.StartMember && xamlArrayReader.Member.Name == "Type")
{
xamlArrayReader.Read();
if (xamlArrayReader.NodeType == XamlNodeType.Value)
{
XamlType arrayType = XamlBuildTaskServices.GetXamlTypeFromString(xamlArrayReader.Value as string, namespaceTable, xamlArrayReader.SchemaContext);
if (arrayType.UnderlyingType != null)
{
paramInfo.Type = xamlArrayReader.SchemaContext.GetXamlType(arrayType.UnderlyingType.MakeArrayType());
}
else
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.AttributeParameterTypeUnknown(arrayType)));
}
}
}
else if (xamlArrayReader.NodeType == XamlNodeType.StartObject)
{
AttributeParameterData arrayEntry = new AttributeParameterData();
ReadParamInfo(xamlArrayReader.ReadSubtree(), null, namespaceTable, rootNamespace, arrayEntry);
paramInfo.AddArrayContentsEntry(arrayEntry);
readNext = true;
}
}
}
else if (reader.NodeType == XamlNodeType.StartObject || reader.NodeType == XamlNodeType.Value)
{
paramInfo.IsArray = false;
string paramVal;
object paramObj = null;
XamlType paramType;
GetParamValueType(reader.ReadSubtree(), type, namespaceTable, rootNamespace, out paramVal, out paramType, out paramObj);
paramInfo.TextValue = paramVal;
paramInfo.Type = paramType;
paramInfo.Value = paramObj;
}
} while (readNext || reader.Read());
}
// Read the parameters on the Attribute. We expect the parameters to be in the order in which they are supposed to appear in the output code.
// Here we are inside x:Arguments and we expect a list of parameters.
private static IList<AttributeParameterData> ReadParameters(XamlReader reader, NamespaceTable namespaceTable, string rootNamespace)
{
IList<AttributeParameterData> parameters = new List<AttributeParameterData>();
bool readNext = false;
while (readNext || reader.Read())
{
readNext = false;
if (reader.NodeType == XamlNodeType.StartObject)
{
AttributeParameterData paramInfo = new AttributeParameterData();
ReadParamInfo(reader.ReadSubtree(), null, namespaceTable, rootNamespace, paramInfo);
parameters.Add(paramInfo);
readNext = true;
}
}
return parameters;
}
