/// <summary>
/// Parses a ContentsOfVariable element in the composition XML.
/// </summary>
public static object ParseWindowsRegistry(XmlElement element, XmlProcessingContext context)
{
if (element.ChildNodes.Count > 0)
{
context.ReportError("'WindowsRegistry' elements should not contain any child elements.");
return(null);
}
string keyPath = null;
string valueName = null;
if (element.Attributes["keyPath"] != null)
{
keyPath = element.Attributes["keyPath"].Value;
}
if (element.Attributes["valueName"] != null)
{
valueName = element.Attributes["valueName"].Value;
}
if (keyPath == null)
{
context.ReportError("'WindowsRegistry' elements require a 'keyPath' attribute.");
return(null);
}
return(ParseWindowsRegistry(keyPath, valueName, context));
}
/// <summary>
/// Used for parsing an Object element in the composition XML.
/// </summary>
public static object ParseObject(XmlElement element, XmlProcessingContext context)
{
string typeName = null;
var initializePlugs = false;
if (element.Attributes["type"] != null)
{
typeName = element.Attributes["type"].Value;
}
if (element.Attributes["initializePlugs"] != null)
{
initializePlugs = Boolean.Parse(element.Attributes["initializePlugs"].Value);
}
if (typeName == null)
{
context.ReportError("'Object' element in the composition XML should have a 'type' attribute.");
return(null);
}
var childElements = new List <XmlElement>();
foreach (XmlNode childNode in element.ChildNodes)
{
if (childNode is XmlElement)
{
childElements.Add((XmlElement)childNode);
}
}
return(ParseObject(typeName, initializePlugs, childElements.ToArray(), context));
}
/// <summary>
/// Parses an Assembly element in the composition XML.
/// </summary>
public static Assembly ParseAssembly(XmlElement element, XmlProcessingContext context)
{
if (element.ChildNodes.Count > 0)
{
context.ReportError("Type elements should not contain any child elements.");
return(null);
}
string assemblyName = null;
if (element.Attributes["name"] != null)
{
assemblyName = element.Attributes["name"].Value;
}
var result = ParseAssembly(assemblyName, context);
if (result == null)
{
context.EnterRunningLocation(string.Format("Assembly({0})", assemblyName));
context.ReportError("Could not load assembly '" + assemblyName + "'.");
context.LeaveRunningLocation();
return(null);
}
return(result);
}
private static void ParseDictionaryItem(IDictionary result, XmlElement childElement,
XmlProcessingContext xmlProcessingContext)
{
if (childElement.GetElementsByTagName("Key").Count != 1)
{
xmlProcessingContext.ReportError(
"Each 'Item' in a 'Dictionary' should contain exactly one 'Key' element as a nested tag.");
return;
}
if (childElement.GetElementsByTagName("Value").Count != 1)
{
xmlProcessingContext.ReportError(
"Each 'Item' in a 'Dictionary' should contain exactly one 'Value' element as a nested tag.");
return;
}
xmlProcessingContext.EnterRunningLocation("Key");
var keyValue =
XmlValueParser.ParseValue((XmlElement)childElement.GetElementsByTagName("Key")[0], xmlProcessingContext, null);
xmlProcessingContext.LeaveRunningLocation();
xmlProcessingContext.EnterRunningLocation("Value");
var valueValue =
XmlValueParser.ParseValue((XmlElement)childElement.GetElementsByTagName("Value")[0], xmlProcessingContext, null);
xmlProcessingContext.LeaveRunningLocation();
result.Add(keyValue, valueValue);
}
/// <summary>
/// Used for parsing short-hand specification of dictionaries in
/// the composition XML.
/// </summary>
public static IDictionary ParseDictionary(IEnumerable <XmlAttribute> attributes, XmlElement[] childElements,
XmlProcessingContext context)
{
string keyType = null;
string valueType = null;
foreach (var attribute in attributes)
{
switch (attribute.Name)
{
case "dictionaryKeyType":
keyType = attribute.Value;
break;
case "dictionaryValueType":
valueType = attribute.Value;
break;
default:
context.ReportError(string.Format("Attribute name {0} is not supported for array value elements.", attribute.Name));
return(null);
}
}
return(ParseDictionary(keyType, valueType, childElements, context));
}
private static void ParseObjectProperty(object result, XmlElement childElement,
XmlProcessingContext xmlProcessingContext)
{
if (childElement.Attributes["name"] == null)
{
xmlProcessingContext.ReportError("'Property' element in the composition XML should have a 'name' attribute.");
return;
}
var propertyName = childElement.Attributes["name"].Value;
xmlProcessingContext.EnterRunningLocation(string.Format("Property({0})", propertyName));
var propertyInfo = result.GetType().GetProperty(propertyName);
if (propertyInfo == null)
{
xmlProcessingContext.ReportError(
string.Format("Object type '{0}' does not contain a property definition named '{1}", result.GetType().FullName,
propertyName));
xmlProcessingContext.LeaveRunningLocation();
return;
}
var propertyValue =
XmlValueParser.ParseValue(childElement, xmlProcessingContext, ObjectPropertyExcludedAttributes);
propertyInfo.SetValue(result, propertyValue, null);
xmlProcessingContext.LeaveRunningLocation();
}
/// <summary>
/// Parses a Ref specification in the short-hand form from a
/// composition XML.
/// </summary>
public static object ParseRef(IEnumerable <XmlAttribute> attributes, XmlProcessingContext context)
{
string refType = null;
string refName = null;
foreach (var attribute in attributes)
{
switch (attribute.Name)
{
case "refType":
refType = attribute.Value;
break;
case "refName":
refName = attribute.Value;
break;
default:
context.ReportError(
string.Format("Attribute name {0} is not supported for ref value elements.", attribute.Name));
return(null);
}
}
if (refType == null)
{
context.ReportError("Attribute 'refType' is required.");
return(null);
}
return(ParseRef(refType, refName, context));
}
/// <summary>
/// Actually parses an Enum specification in the composition XML, and
/// is used in both element form, and short-hand forms.
/// </summary>
public static object ParseEnum(string enumTypeName, string enumValue, XmlProcessingContext context)
{
if (enumTypeName == null)
{
throw new ArgumentNullException("enumTypeName");
}
if (enumValue == null)
{
throw new ArgumentNullException("enumValue");
}
context.EnterRunningLocation(string.Format("enum({0}, {1})", enumTypeName, enumValue));
var enumType = ParseType(enumTypeName, context);
if (enumType == null)
{
context.ReportError(string.Format("Type '{0}' could not be loaded.", enumTypeName));
return(null);
}
if (!enumType.IsValueType)
{
context.ReportError(
string.Format("Type '{0}' is not an enumeration type, and can not be used in <EnumValue> tag.", enumType));
return(null);
}
var result = Enum.Parse(enumType, enumValue);
context.LeaveRunningLocation();
return(result);
}
/// <summary>
/// Parses an enum value in its short-hand form in composition XML.
/// </summary>
public static object ParseEnum(IEnumerable <XmlAttribute> attributes, XmlProcessingContext context)
{
string enumType = null;
string enumValue = null;
foreach (var attribute in attributes)
{
switch (attribute.Name)
{
case "enumType":
enumType = attribute.Value;
break;
case "enumValue":
enumValue = attribute.Value;
break;
default:
context.ReportError(
string.Format("Attribute name {0} is not supported for enum value elements.", attribute.Name));
return(null);
}
}
if ((enumValue == null) || (enumType == null))
{
context.ReportError("Both 'enumType' and 'enumValue' attributes are required.");
return(null);
}
return(ParseEnum(enumType, enumValue, context));
}
private static void ParseObjectField(object result, XmlElement childElement, XmlProcessingContext xmlProcessingContext)
{
if (childElement.Attributes["name"] == null)
{
xmlProcessingContext.ReportError("'Field' element in the composition XML should have a 'name' attribute.");
return;
}
var fieldName = childElement.Attributes["name"].Value;
xmlProcessingContext.EnterRunningLocation(string.Format("Field({0})", fieldName));
var fieldInfo = result.GetType().GetField(fieldName);
if (fieldInfo == null)
{
xmlProcessingContext.ReportError(
string.Format("Object type '{0}' does not contain a field definition named '{1}", result.GetType().FullName,
fieldName));
xmlProcessingContext.LeaveRunningLocation();
return;
}
var fieldValue = XmlValueParser.ParseValue(childElement, xmlProcessingContext, objectFieldExcludedAttributes);
fieldInfo.SetValue(result, fieldValue);
xmlProcessingContext.LeaveRunningLocation();
}
/// <summary>
/// Parses a Dictionary element in the composition XML.
/// </summary>
public static IDictionary ParseDictionary(XmlElement element, XmlProcessingContext xmlProcessingContext)
{
string keyTypeName = null;
string valueTypeName = null;
if (element.Attributes["keyType"] != null)
{
keyTypeName = element.Attributes["keyType"].Value;
}
if (element.Attributes["valueType"] != null)
{
valueTypeName = element.Attributes["valueType"].Value;
}
var childElements = new List <XmlElement>();
foreach (XmlNode childNode in element.ChildNodes)
{
if (childNode is XmlElement xmlElement)
{
childElements.Add(xmlElement);
}
}
return(ParseDictionary(keyTypeName, valueTypeName, childElements.ToArray(), xmlProcessingContext));
}
internal static void ProcessCompositionXml(Stream configurationStream, XmlProcessingContext xmlProcessingContext)
{
if (configurationStream == null)
{
throw new ArgumentNullException(nameof(configurationStream));
}
var xsdStream =
typeof(AssemblyPointer).Assembly.GetManifestResourceStream(
"ComposerCore.CompositionXml.Schema.compositionXml.1.0.xsd");
if (xsdStream == null)
{
throw new NullReferenceException("Could not load XSD resource from DLL.");
}
var schema =
XmlSchema.Read(
xsdStream,
(sender, e) => throw new CompositionXmlValidationException(
"Could not load XSD for Composition XML. Message: " + e.Message + "; Sender: " +
sender, e.Exception));
var schemaSet = new XmlSchemaSet();
schemaSet.Add(schema);
var settings = new XmlReaderSettings {
ValidationType = ValidationType.Schema, Schemas = schemaSet
};
settings.ValidationEventHandler += delegate(object sender, ValidationEventArgs e)
{
var errorMessage = "Composition XML Schema Validation error: ";
if (e.Exception is XmlSchemaValidationException validationException)
{
errorMessage += "Line: " + validationException.LineNumber + ", Position: " +
validationException.LinePosition +
"; " + validationException.Message;
}
else
{
errorMessage += "Message: " + e.Message + "; Sender: " + sender +
"; Inner exception: " + e.Exception.Message;
}
xmlProcessingContext.ReportError(errorMessage);
};
var serializer = new XmlSerializer(typeof(CompositionInfo));
var reader = XmlReader.Create(configurationStream, settings);
var info = (CompositionInfo)serializer.Deserialize(reader);
info.Validate();
CompositionInfoApplicator.ApplyCompositionInfo(info, xmlProcessingContext);
}
/// <summary>
/// Actually parses contentsOfVariable string, looking up the variable name. Used in
/// both short-hand form and element form of contentsOfVariable specification.
/// </summary>
public static object ParseWindowsRegistry(string keyPath, string valueName, XmlProcessingContext context)
{
if (keyPath == null)
{
throw new ArgumentNullException("keyPath");
}
return(Registry.GetValue(keyPath, valueName, null));
}
/// <summary>
/// Parses a contentsOfVariableName specification in composition XML in its short-hand form.
/// </summary>
public static object ParseTimeSpan(IEnumerable <XmlAttribute> attributes, XmlProcessingContext context)
{
// Declare variables for possible input values
string timeSpanString = null;
int? days = null;
int? hours = null;
int? minutes = null;
int? seconds = null;
int? milliseconds = null;
long? ticks = null;
// Extract input values from the attributes (can be in any order)
foreach (var attribute in attributes)
{
switch (attribute.Name)
{
case "timeSpan":
timeSpanString = attribute.Value;
break;
case "timeSpanDays":
days = Int32.Parse(attribute.Value);
break;
case "timeSpanHours":
hours = Int32.Parse(attribute.Value);
break;
case "timeSpanMinutes":
minutes = Int32.Parse(attribute.Value);
break;
case "timeSpanSeconds":
seconds = Int32.Parse(attribute.Value);
break;
case "timeSpanMilliseconds":
milliseconds = Int32.Parse(attribute.Value);
break;
case "timeSpanTicks":
ticks = Int64.Parse(attribute.Value);
break;
default:
context.ReportError(
string.Format("Attribute name {0} is not supported for timeSpan value elements.", attribute.Name));
return(null);
}
}
// Validate and parse the extracted values
return(ParseTimeSpan(timeSpanString, days, hours, minutes, seconds, milliseconds, ticks, context));
}
/// <summary>
/// Actually parses a Type string, looking up the type name. Used in
/// both short-hand form and element form of type specification.
/// </summary>
public static Type ParseType(string typeName, XmlProcessingContext context)
{
if (typeName == null)
{
throw new ArgumentNullException("typeName");
}
var result = context.TypeCache.LookupType(typeName) ?? Type.GetType(typeName, false, false);
return(result);
}
/// <summary>
/// Actually parses an Assembly string, trying to load the assembly object. Used in
/// both short-hand form and element form of assembly specification.
/// </summary>
public static Assembly ParseAssembly(string assemblyName, XmlProcessingContext context)
{
if (assemblyName == null)
{
throw new ArgumentNullException("assemblyName");
}
var result = Assembly.Load(assemblyName);
return(result);
}
public static void ProcessCompositionXmlFromResource(this IComponentContext context, Assembly assembly, string configurationResourceName)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var xmlProcessingContext = new XmlProcessingContext(context);
ProcessCompositionXmlFromResource(assembly, configurationResourceName, xmlProcessingContext);
xmlProcessingContext.ThrowIfErrors();
}
public static void ProcessCompositionXml(this IComponentContext context, string configurationPath)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var xmlProcessingContext = new XmlProcessingContext(context);
ProcessCompositionXml(configurationPath, xmlProcessingContext);
xmlProcessingContext.ThrowIfErrors();
}
internal static void ProcessCompositionXmlFromResource(Assembly assembly, string configurationResourceName,
XmlProcessingContext xmlProcessingContext)
{
var stream = assembly.GetManifestResourceStream(configurationResourceName);
if (stream == null)
{
xmlProcessingContext.ReportError($"Resource name '{configurationResourceName}' could not be loaded from assembly '{assembly.FullName}'.");
return;
}
ProcessCompositionXml(stream, xmlProcessingContext);
}
public static object ParseValue(XmlElement[] elements, XmlAttribute[] attributes,
XmlProcessingContext xmlProcessingContext, List <string> excludedAttributes)
{
if ((excludedAttributes == null) || (excludedAttributes.Count == 0))
{
return(ParseValue(elements, attributes, xmlProcessingContext));
}
var filteredAttributes =
Array.FindAll(attributes,
attribute => !(excludedAttributes.Contains(attribute.Name)));
return(ParseValue(elements, filteredAttributes, xmlProcessingContext));
}
public static byte[] ParseByteArray(string value, XmlProcessingContext context)
{
var filteredString = "";
// remove all none A-F, 0-9, characters
for (var i = 0; i < value.Length; i++)
{
var c = value[i];
if ((char.IsWhiteSpace(c)) ||
(c == '-') ||
(c == '_'))
{
continue;
}
if (!char.IsLetterOrDigit(c))
{
context.ReportError("Character is not allowed in a hex string: '" + c + "', ignoring.");
continue;
}
c = char.ToUpper(c);
if ((char.IsLetter(c)) && ((c > 'F') || (c < 'A')))
{
context.ReportError("Character is not allowed in a hex string: '" + c + "', ignoring.");
continue;
}
filteredString += c;
}
// if odd number of characters, add a zero to the beginning
if (filteredString.Length % 2 != 0)
{
filteredString = "0" + filteredString;
}
var byteLength = filteredString.Length / 2;
var result = new byte[byteLength];
for (var i = 0; i < result.Length; i++)
{
result[i] = byte.Parse(filteredString.Substring(i << 1, 2), NumberStyles.HexNumber);
}
return(result);
}
/// <summary>
/// Actually parses contentsOfVariable string, looking up the variable name. Used in
/// both short-hand form and element form of contentsOfVariable specification.
/// </summary>
public static object ParseContentsOfVariable(string variableName, XmlProcessingContext context)
{
if (variableName == null)
{
throw new ArgumentNullException("variableName");
}
context.EnterRunningLocation(string.Format("Parsing ContentsOfVariable({0})", variableName));
var result = context.ComponentContext.GetVariable(variableName);
context.LeaveRunningLocation();
return(result);
}
internal static void ProcessCompositionXml(string configurationPath, XmlProcessingContext xmlProcessingContext)
{
if (configurationPath == null)
{
throw new ArgumentNullException(nameof(configurationPath));
}
if (!File.Exists(configurationPath))
{
xmlProcessingContext.ReportError($"Specified configuration file '{configurationPath}' does not exist.");
return;
}
using (Stream configurationStream = File.Open(configurationPath, FileMode.Open, FileAccess.Read))
{
ProcessCompositionXml(configurationStream, xmlProcessingContext);
}
}
/// <summary>
/// Parses a SerializeBinary element in the composition XML.
/// </summary>
public static object ParseSerializeBinary(XmlElement element, XmlProcessingContext context)
{
context.EnterRunningLocation("SerializeBinary");
var serializableValue = XmlValueParser.ParseValue(element, context, null);
var formatter = new BinaryFormatter();
var stream = new MemoryStream();
formatter.Serialize(stream, serializableValue);
var result = stream.ToArray();
stream.Close();
context.LeaveRunningLocation();
return(result);
}
/// <summary>
/// Used when parsing an Array element in composition XML.
/// </summary>
public static Array ParseArray(XmlElement element, XmlProcessingContext xmlProcessingContext)
{
string elementTypeName = null;
if (element.Attributes["elementType"] != null)
{
elementTypeName = element.Attributes["elementType"].Value;
}
var childElements = new List <XmlElement>();
foreach (XmlNode childNode in element.ChildNodes)
{
if (childNode is XmlElement xmlElement)
{
childElements.Add(xmlElement);
}
}
return(ParseArray(elementTypeName, childElements.ToArray(), xmlProcessingContext));
}
private static List <object> GetCollectionElements(XmlElement[] xmlElements, Type elementType,
XmlProcessingContext xmlProcessingContext)
{
var arrayElements = new List <object>();
for (var i = 0; i < xmlElements.Length; i++)
{
xmlProcessingContext.EnterRunningLocation(string.Format("Item({0})", i));
var childElement = xmlElements[i];
if (childElement.Name == "Item")
{
var arrayElement = XmlValueParser.ParseValue(childElement, xmlProcessingContext, null);
if ((arrayElement != null) && (!elementType.IsInstanceOfType(arrayElement)))
{
xmlProcessingContext.ReportError(
string.Format("Array of the element type {0} can not contain items with type {1}.", elementType.FullName,
arrayElement.GetType().FullName));
xmlProcessingContext.LeaveRunningLocation();
return(null);
}
arrayElements.Add(arrayElement);
}
else
{
xmlProcessingContext.ReportError(
string.Format("Xml element '{0}' is not allowed in 'Array' element - type: {1}[]", childElement.Name,
elementType.FullName));
xmlProcessingContext.LeaveRunningLocation();
return(null);
}
xmlProcessingContext.LeaveRunningLocation();
}
return(arrayElements);
}
private static object[] ParseConstructorArgs(XmlElement element,
XmlProcessingContext xmlProcessingContext)
{
if (element.Name != "ConstructorArgs")
{
throw new ArgumentException("Calling this method is only valid for 'ConstructorArgs' element.");
}
if (element.HasAttributes)
{
xmlProcessingContext.ReportError("'ConstructorArgs' element should not have any attributes.");
}
xmlProcessingContext.EnterRunningLocation("ConstructorArgs");
var result = new List <object>();
foreach (XmlNode childNode in element.ChildNodes)
{
var childElement = childNode as XmlElement;
if (childElement == null)
{
continue;
}
if (childElement.Name == "Arg")
{
result.Add(XmlValueParser.ParseValue(childElement, xmlProcessingContext, null));
}
else
{
xmlProcessingContext.ReportError(
string.Format("Element '{0}' is not allowed in the 'ConstructorArgs' element.", childElement.Name));
}
}
xmlProcessingContext.LeaveRunningLocation();
return(result.ToArray());
}
/// <summary>
/// Parses a ContentsOfVariable element in the composition XML.
/// </summary>
public static object ParseContentsOfVariable(XmlElement element, XmlProcessingContext context)
{
if (element.ChildNodes.Count > 0)
{
context.ReportError("'ContentsOfVariable' elements should not contain any child elements.");
return(null);
}
string variableName = null;
if (element.Attributes["name"] != null)
{
variableName = element.Attributes["name"].Value;
}
if (variableName == null)
{
context.ReportError("'ContentsOfVariable' elements require a 'name' attribute.");
return(null);
}
return(ParseContentsOfVariable(variableName, context));
}
/// <summary>
/// Parses a Ref element in the composition XML.
/// </summary>
public static object ParseRef(XmlElement element, XmlProcessingContext context)
{
if (element.ChildNodes.Count > 0)
{
context.ReportError("Ref elements should not contain any child elements.");
return(null);
}
string refType = null;
string refName = null;
if (element.Attributes["type"] != null)
{
refType = element.Attributes["type"].Value;
}
if (element.Attributes["name"] != null)
{
refName = element.Attributes["name"].Value;
}
return(ParseRef(refType, refName, context));
}
/// <summary>
/// Actually parses the contents on Ref specification in composition XML.
/// Looks up the referenced component in the component context, and returns the result.
/// Is used both in short-hand form and element form on Ref specification.
/// </summary>
public static object ParseRef(string refTypeName, string refName, XmlProcessingContext context)
{
if (refTypeName == null)
{
throw new ArgumentNullException("refTypeName");
}
context.EnterRunningLocation(string.Format("Ref({0})", refTypeName));
var refType = ParseType(refTypeName, context);
if (refType == null)
{
context.ReportError(string.Format("Type '{0}' could not be loaded.", refTypeName));
return(null);
}
var result = context.ComponentContext.GetComponent(refType, refName);
context.LeaveRunningLocation();
return(result);
}
