/// <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); }