private static void buildMembers(ref Dictionary <string, XmlMemberSerialiser> members, NetReflectorTypeTable typeTable, XmlNode node)
{
if (node == null)
{
return;
}
var nodeType = typeTable.ContainsType(node.Name) ? typeTable[node.Name] : null;
if (nodeType != null)
{
foreach (XmlMemberSerialiser value in nodeType.MemberSerialisers)
{
if (value != null)
{
if (!members.ContainsKey(value.Attribute.Name))
{
members.Add(value.Attribute.Name, value);
}
}
}
}
foreach (XmlNode childNode in node.ChildNodes)
{
buildMembers(ref members, typeTable, childNode);
}
}
private static void buildImputMembers(ref Dictionary <string, XmlMemberSerialiser> inputMembers, NetReflectorTypeTable typeTable, XmlNode inputNode)
{
var inputNodeType = typeTable.ContainsType(inputNode.Name) ? typeTable[inputNode.Name] : null;
if (inputNodeType != null)
{
foreach (XmlMemberSerialiser value in inputNodeType.MemberSerialisers)
{
if (value != null)
{
if (!inputMembers.ContainsKey(value.Attribute.Name))
{
inputMembers.Add(value.Attribute.Name, value);
}
}
}
}
foreach (XmlNode childNode in inputNode.ChildNodes)
{
buildImputMembers(ref inputMembers, typeTable, childNode);
}
}
/// <summary>
/// Check for and convert inline XML dynamic value notation into <see cref="IDynamicValue"/> definitions.
/// </summary>
/// <param name="typeTable">The type table.</param>
/// <param name="inputNode">The node to process.</param>
/// <param name="exclusions">Any elements to exclude.</param>
/// <returns></returns>
public static XmlNode ConvertXmlToDynamicValues(NetReflectorTypeTable typeTable, XmlNode inputNode, params string[] exclusions)
{
var resultNode = inputNode;
var doc = inputNode.OwnerDocument;
var parameters = new List <XmlElement>();
// Initialise the values from the reflection
var inputMembers = new Dictionary <string, XmlMemberSerialiser>();
buildMembers(ref inputMembers, typeTable, inputNode);
var nodes = inputNode.SelectNodes("descendant::text()|descendant-or-self::*[@*]/@*");
foreach (XmlNode nodeWithParam in nodes)
{
var text = nodeWithParam.Value;
var isExcluded = CheckForExclusion(nodeWithParam, exclusions);
if (!isExcluded && parameterRegex.Match(text).Success)
{
// Generate the format string
var parametersEl = doc.CreateElement("parameters");
var index = 0;
var lastReplacement = string.Empty;
var format = parameterRegex.Replace(text, (match) =>
{
// Split into it's component parts
var parts = paramPartRegex.Split(match.Value.Substring(2, match.Value.Length - 3));
// Generate the value element
var dynamicValueEl = doc.CreateElement("namedValue");
dynamicValueEl.SetAttribute("name", parts[0].Replace("\\|", "|"));
if (parts.Length > 1)
{
dynamicValueEl.SetAttribute("value", parts[1].Replace("\\|", "|"));
}
parametersEl.AppendChild(dynamicValueEl);
// Generate the replacement
lastReplacement = string.Format(CultureInfo.CurrentCulture, "{{{0}{1}}}",
index++,
parts.Length > 2 ? ":" + parts[2].Replace("\\|", "|") : string.Empty);
return(lastReplacement);
});
// Generate the dynamic value element
var replacementValue = string.Empty;
XmlElement replacementEl;
if (lastReplacement != format)
{
replacementEl = doc.CreateElement("replacementValue");
AddElement(replacementEl, "format", format);
replacementEl.AppendChild(parametersEl);
}
else
{
replacementEl = doc.CreateElement("directValue");
AddElement(replacementEl, "parameter", parametersEl.SelectSingleNode("namedValue/@name").InnerText);
var innerValue = parametersEl.SelectSingleNode("namedValue/@value");
if (innerValue != null)
{
replacementValue = innerValue.InnerText;
AddElement(replacementEl, "default", replacementValue);
}
}
parameters.Add(replacementEl);
// Generate the path
var propertyName = new StringBuilder();
var currentNode = nodeWithParam is XmlAttribute ? nodeWithParam : nodeWithParam.ParentNode;
var previousNode = currentNode;
var lastName = string.Empty;
bool hasDynamicValues = false;
while ((currentNode != inputNode) && (currentNode != null))
{
var nodeName = currentNode.Name;
var currentNodeType = typeTable.ContainsType(nodeName) ? typeTable[nodeName] : null;
if (currentNodeType != null)
{
hasDynamicValues = currentNodeType.Type.
GetInterface(typeof(IWithDynamicValuesItem).Name) != null;
if (hasDynamicValues)
{
break;
}
}
// Check if we are dealing with an array
if (inputMembers.ContainsKey(nodeName) && inputMembers[nodeName].ReflectorMember.MemberType.IsArray)
{
// Do some convoluted processing to handle array items
propertyName.Remove(0, lastName.Length + 1); // Remove the previous name, since this is now an index position
var position = 0;
var indexNode = previousNode;
// Find the index of the node
while (indexNode.PreviousSibling != null)
{
if (indexNode.NodeType != XmlNodeType.Comment)
{
position++;
}
indexNode = indexNode.PreviousSibling;
}
// Add the node as an indexed node
propertyName.Insert(0, "." + nodeName + "[" + position.ToString(CultureInfo.CurrentCulture) + "]");
}
else
{
// Just add the node name
propertyName.Insert(0, "." + nodeName);
}
// Move to the parent
lastName = nodeName;
previousNode = currentNode;
currentNode = getParentNode(currentNode);
}
propertyName.Remove(0, 1);
AddElement(replacementEl, "property", propertyName.ToString());
// Set a replacement value
nodeWithParam.Value = replacementValue;
// add the parameters already there if the current node has dynamic values
if (hasDynamicValues)
{
addParameters(ref parameters, currentNode);
}
}
}
// Add the remaining parameters to the root element
addParameters(ref parameters, inputNode);
return(resultNode);
}
