/// <summary> /// Gets all the attributes assigned in the xml file for this parameter or all of the nested switches for /// this parameter group /// </summary> private Property ObtainAttributes(XamlTypes.BaseProperty baseProperty, Property parameterGroup) { Property parameter; if (parameterGroup != null) { parameter = parameterGroup.Clone(); } else { parameter = new Property(); } XamlTypes.BoolProperty boolProperty = baseProperty as XamlTypes.BoolProperty; XamlTypes.DynamicEnumProperty dynamicEnumProperty = baseProperty as XamlTypes.DynamicEnumProperty; XamlTypes.EnumProperty enumProperty = baseProperty as XamlTypes.EnumProperty; XamlTypes.IntProperty intProperty = baseProperty as XamlTypes.IntProperty; XamlTypes.StringProperty stringProperty = baseProperty as XamlTypes.StringProperty; XamlTypes.StringListProperty stringListProperty = baseProperty as XamlTypes.StringListProperty; parameter.IncludeInCommandLine = baseProperty.IncludeInCommandLine; if (baseProperty.Name != null) { parameter.Name = baseProperty.Name; } if (boolProperty != null && !String.IsNullOrEmpty(boolProperty.ReverseSwitch)) { parameter.Reversible = "true"; } // Determine the type for this property. if (boolProperty != null) { parameter.Type = PropertyType.Boolean; } else if (enumProperty != null) { parameter.Type = PropertyType.String; } else if (dynamicEnumProperty != null) { parameter.Type = PropertyType.String; } else if (intProperty != null) { parameter.Type = PropertyType.Integer; } else if (stringProperty != null) { parameter.Type = PropertyType.String; } else if (stringListProperty != null) { parameter.Type = PropertyType.StringArray; } // We might need to override this type based on the data source, if it specifies a source type of 'Item'. if (baseProperty.DataSource != null) { if (!String.IsNullOrEmpty(baseProperty.DataSource.SourceType)) { if (baseProperty.DataSource.SourceType.Equals("Item", StringComparison.OrdinalIgnoreCase)) { parameter.Type = PropertyType.ItemArray; } } } if (intProperty != null) { parameter.Max = intProperty.MaxValue != null ? intProperty.MaxValue.ToString() : null; parameter.Min = intProperty.MinValue != null ? intProperty.MinValue.ToString() : null; } if (boolProperty != null) { parameter.ReverseSwitchName = boolProperty.ReverseSwitch; } if (baseProperty.Switch != null) { parameter.SwitchName = baseProperty.Switch; } if (stringListProperty != null) { parameter.Separator = stringListProperty.Separator; } if (baseProperty.Default != null) { parameter.DefaultValue = baseProperty.Default; } parameter.Required = baseProperty.IsRequired.ToString().ToLower(CultureInfo.InvariantCulture); if (baseProperty.Category != null) { parameter.Category = baseProperty.Category; } if (baseProperty.DisplayName != null) { parameter.DisplayName = baseProperty.DisplayName; } if (baseProperty.Description != null) { parameter.Description = baseProperty.Description; } if (baseProperty.SwitchPrefix != null) { parameter.Prefix = baseProperty.SwitchPrefix; } return parameter; }
/// <summary> /// Fills in the property data structure /// </summary> private bool ParseParameter(XamlTypes.BaseProperty baseProperty, LinkedList<Property> propertyList, Property property, Dictionary<string, Property> argumentDependencyLookup) { Property propertyToAdd = ObtainAttributes(baseProperty, property); if (String.IsNullOrEmpty(propertyToAdd.Name)) { propertyToAdd.Name = "AlwaysAppend"; } // generate the list of parameters in order if (!_switchesAdded.Contains(propertyToAdd.Name)) { _switchOrderList.Add(propertyToAdd.Name); _switchesAdded.Add(propertyToAdd.Name); } // Inherit the Prefix from the Tool if (String.IsNullOrEmpty(propertyToAdd.Prefix)) { propertyToAdd.Prefix = DefaultPrefix; } // If the property is an enum type, parse that. XamlTypes.EnumProperty enumProperty = baseProperty as XamlTypes.EnumProperty; if (enumProperty != null) { foreach (XamlTypes.EnumValue enumValue in enumProperty.AdmissibleValues) { Value value = new Value(); value.Name = enumValue.Name; value.SwitchName = enumValue.Switch; if (value.SwitchName == null) { value.SwitchName = String.Empty; } value.DisplayName = enumValue.DisplayName; value.Description = enumValue.Description; value.Prefix = enumValue.SwitchPrefix; if (String.IsNullOrEmpty(value.Prefix)) { value.Prefix = enumProperty.SwitchPrefix; } if (String.IsNullOrEmpty(value.Prefix)) { value.Prefix = DefaultPrefix; } if (enumValue.Arguments.Count > 0) { value.Arguments = new List<Argument>(); foreach (XamlTypes.Argument argument in enumValue.Arguments) { Argument arg = new Argument(); arg.Parameter = argument.Property; arg.Separator = argument.Separator; arg.Required = argument.IsRequired; value.Arguments.Add(arg); } } if (value.Prefix == null) { value.Prefix = propertyToAdd.Prefix; } propertyToAdd.Values.Add(value); } } // build the dependencies and the values for a parameter foreach (XamlTypes.Argument argument in baseProperty.Arguments) { // To refactor into a separate func if (propertyToAdd.Arguments == null) { propertyToAdd.Arguments = new List<Argument>(); } Argument arg = new Argument(); arg.Parameter = argument.Property; arg.Separator = argument.Separator; arg.Required = argument.IsRequired; propertyToAdd.Arguments.Add(arg); } if (argumentDependencyLookup != null && !argumentDependencyLookup.ContainsKey(propertyToAdd.Name)) { argumentDependencyLookup.Add(propertyToAdd.Name, propertyToAdd); } // We've read any enumerated values and any dependencies, so we just // have to add the property propertyList.AddLast(propertyToAdd); return true; }
/// <summary> /// Reads in the nodes of the xml file one by one and builds the data structure of all existing properties /// </summary> private bool ParseParameterGroupOrParameter(XamlTypes.BaseProperty baseProperty, LinkedList<Property> propertyList, Property property, Dictionary<string, Property> argumentDependencyLookup) { // node is a property if (!ParseParameter(baseProperty, propertyList, property, argumentDependencyLookup)) { return false; } return true; }
/// <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; _name = 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. Dictionary<string, Property> 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) { Property argumentProperty = null; if (argumentDependencyLookup.TryGetValue(argument.Parameter, out 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) { Property argumentProperty = null; if (argumentDependencyLookup.TryGetValue(argument.Parameter, out 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; }
/// <summary> /// The list of switches in the order they should appear, if set. /// </summary> private Dictionary<String, Object> parseParameters(XamlTypes.Rule rule) { Dictionary<String, Object> parameterValues = new Dictionary<string, object>(); Dictionary<string, string> strOptions = parseParamValues(Parameters); foreach (XamlTypes.BaseProperty property in rule.Properties) { string val; if (strOptions.TryGetValue(property.Name, out val)) { XamlTypes.BoolProperty boolProperty = property as XamlTypes.BoolProperty; XamlTypes.DynamicEnumProperty dynamicEnumProperty = property as XamlTypes.DynamicEnumProperty; XamlTypes.EnumProperty enumProperty = property as XamlTypes.EnumProperty; XamlTypes.IntProperty intProperty = property as XamlTypes.IntProperty; XamlTypes.StringProperty stringProperty = property as XamlTypes.StringProperty; XamlTypes.StringListProperty stringListProperty = property as XamlTypes.StringListProperty; if (stringListProperty != null) { string[] values = val.Split(';'); parameterValues[property.Name] = values; } else if (boolProperty != null) { parameterValues[property.Name] = string.Compare(val, "true", StringComparison.OrdinalIgnoreCase) == 0; } else if (intProperty != null) { parameterValues[property.Name] = Int64.Parse(val); } else parameterValues[property.Name] = val; } } return parameterValues; }
private bool parseParameters(XamlTypes.Rule rule) { Dictionary<string, string> strOptions = new Dictionary<string, string>(); string[] paras = Parameters.Split('|'); foreach (string p in paras) { int pos = p.IndexOf('='); string name = p.Substring(0, pos); string value = p.Substring(pos + 1); strOptions[name] = value; switchOrderList.Add(name); } foreach (XamlTypes.BaseProperty property in rule.Properties) { string val; if (strOptions.TryGetValue(property.Name, out val)) { XamlTypes.BoolProperty boolProperty = property as XamlTypes.BoolProperty; XamlTypes.DynamicEnumProperty dynamicEnumProperty = property as XamlTypes.DynamicEnumProperty; XamlTypes.EnumProperty enumProperty = property as XamlTypes.EnumProperty; XamlTypes.IntProperty intProperty = property as XamlTypes.IntProperty; XamlTypes.StringProperty stringProperty = property as XamlTypes.StringProperty; XamlTypes.StringListProperty stringListProperty = property as XamlTypes.StringListProperty; if (stringListProperty != null) { string[] values = val.Split(';'); parameterValues[property.Name] = values; } else if (boolProperty != null) { parameterValues[property.Name] = string.Compare(val, "true", StringComparison.OrdinalIgnoreCase) == 0; } else if (intProperty != null) { parameterValues[property.Name] = Int64.Parse(val); } else parameterValues[property.Name] = val; } } return true; }