/// <summary>
/// Parse a Xaml document from a TextReader
/// </summary>
internal bool ParseXamlDocument(TextReader reader, string desiredRule)
{
ErrorUtilities.VerifyThrowArgumentNull(reader, nameof(reader));
ErrorUtilities.VerifyThrowArgumentLength(desiredRule, nameof(desiredRule));
object rootObject = XamlServices.Load(reader);
if (null != rootObject)
{
XamlTypes.ProjectSchemaDefinitions schemas = rootObject as XamlTypes.ProjectSchemaDefinitions;
if (schemas != null)
{
foreach (XamlTypes.IProjectSchemaNode node in schemas.Nodes)
{
XamlTypes.Rule rule = node as XamlTypes.Rule;
if (rule != null)
{
if (String.Equals(rule.Name, desiredRule, StringComparison.OrdinalIgnoreCase))
{
return(ParseXamlDocument(rule));
}
}
}
throw new XamlParseException(ResourceUtilities.FormatResourceStringStripCodeAndKeyword("Xaml.RuleNotFound", desiredRule));
}
else
{
throw new XamlParseException(ResourceUtilities.GetResourceString("Xaml.InvalidRootObject"));
}
}
return(false);
}
/// <summary>
/// Parse a Xaml document from a rule
/// </summary>
internal bool ParseXamlDocument(XamlTypes.Rule rule)
{
if (rule == null)
{
return(false);
}
DefaultPrefix = rule.SwitchPrefix;
ToolName = rule.ToolName;
GeneratedTaskName = rule.Name;
// Dictionary of property name strings to property objects. If a property is in the argument list of the current property then we want to make sure
// that the argument property is a dependency of the current property.
// As properties are parsed they are added to this dictionary so that after we can find the property instances from the names quickly.
var argumentDependencyLookup = new Dictionary <string, Property>(StringComparer.OrdinalIgnoreCase);
// baseClass = attribute.InnerText;
// namespaceValue = attribute.InnerText;
// resourceNamespaceValue = attribute.InnerText;
foreach (XamlTypes.BaseProperty property in rule.Properties)
{
if (!ParseParameterGroupOrParameter(property, Properties, null, argumentDependencyLookup /*Add to the dictionary properties as they are parsed*/))
{
return(false);
}
}
// Go through each property and their arguments to set up the correct dependency mappings.
foreach (Property property in Properties)
{
// Get the arguments on the property itself
List <Argument> arguments = property.Arguments;
// Find all of the properties in arguments list.
foreach (Argument argument in arguments)
{
if (argumentDependencyLookup.TryGetValue(argument.Parameter, out Property argumentProperty))
{
property.DependentArgumentProperties.AddLast(argumentProperty);
}
}
// Properties may be enumeration types, this would mean they have sub property values which themselves can have arguments.
List <Value> values = property.Values;
// Find all of the properties for the aruments in sub property.
foreach (Value value in values)
{
List <Argument> valueArguments = value.Arguments;
foreach (Argument argument in valueArguments)
{
if (argumentDependencyLookup.TryGetValue(argument.Parameter, out Property argumentProperty))
{
// If the property contains a value sub property that has a argument then we will declare that the original property has the same dependenecy.
property.DependentArgumentProperties.AddLast(argumentProperty);
}
}
}
}
return(true);
}
