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