private ConstructionNode ProcessNode(XElement node, IPrefixAnnotator annotator)
{
var elementType = xmlTypeResolver.LocateType(node.Name);
var directives = directiveExtractor.GetDirectives(node).ToList();
var type = GetFinalTypeAccordingToDirectives(elementType, directives);
var rawAssigments = assignmentExtractor.GetAssignments(type, node, annotator).ToList();
var attributeBasedInstanceProperties = CombineDirectivesAndAssigments(type, directives, rawAssigments);
var children = GetChildren(type, node, annotator).ToList();
var ctorArgs = GetCtorArgs(node, type);
var constructionNode = new ConstructionNode(elementType)
{
Name = attributeBasedInstanceProperties.Name,
Key = attributeBasedInstanceProperties.Key,
PositionalParameters = ctorArgs,
InstantiateAs = type == elementType ? null : type,
}.WithAssignments(attributeBasedInstanceProperties.Assignments.ToList())
.WithChildren(children);
AnnotatePrefixes(node, annotator, constructionNode);
return(constructionNode);
}
private static void AnnotatePrefixes(XElement node, IPrefixAnnotator annotator, ConstructionNode constructionNode)
{
var prefixes = GetPrefixes(node).ToList();
if (prefixes.Any())
{
annotator.Annotate(constructionNode, prefixes);
}
}
public ParseResult Parse(string xml, IPrefixAnnotator prefixAnnotator)
{
var xDocument = XDocument.Load(new StringReader(xml));
var node = xDocument.FirstNode;
return(new ParseResult
{
Root = ProcessNode((XElement)node, prefixAnnotator),
PrefixAnnotator = prefixAnnotator,
});
}
private IEnumerable <ConstructionNode> GetChildren(Type type, XElement node, IPrefixAnnotator annotator)
{
var hasContentProperty = metadataProvider.Get(type).ContentProperty != null;
if (!hasContentProperty)
{
var childNodes = node.Nodes().OfType <XElement>().Where(element => !IsProperty(element));
return(childNodes.Select(e => ProcessNode(e, annotator)));
}
return(new List <ConstructionNode>());
}
public PrefixedTypeResolver(IPrefixAnnotator annotator, ITypeDirectory typeDirectory)
{
this.annotator = annotator;
this.typeDirectory = typeDirectory;
}
private IEnumerable <MemberAssignment> FromPropertyElements(Type type, XElement element, IPrefixAnnotator annotator)
{
var propertyElements = element.Elements().Where(IsProperty);
foreach (var propertyElement in propertyElements)
{
yield return(FromPropertyElement(type, propertyElement, annotator));
}
}
private IEnumerable <MemberAssignment> FromContentProperty(Type type, XElement element, IPrefixAnnotator annotator)
{
var contentProperty = metadataProvider.Get(type).ContentProperty;
if (contentProperty == null)
{
yield break;
}
var propertyElements = GetPropertyElements(element);
var propertyElementsList = propertyElements.ToList();
if (propertyElementsList.Any())
{
yield return(new MemberAssignment
{
Member = Member.FromStandard(type, contentProperty),
Values = propertyElementsList.Select(e => createFunc(e, annotator)).ToList()
});
}
else
{
var elementFirstNode = element.FirstNode;
if (elementFirstNode != null && IsText(elementFirstNode))
{
yield return(new MemberAssignment
{
Member = Member.FromStandard(type, contentProperty),
SourceValue = ((XText)elementFirstNode).Value,
});
}
}
}
public IEnumerable <MemberAssignment> GetAssignments(Type owner, XElement element, IPrefixAnnotator annotator)
{
EnsureValidAssignments(element);
var fromAttributes = FromAttributes(owner, element);
var fromPropertyElements = FromPropertyElements(owner, element, annotator);
var fromContentProperty = FromContentProperty(owner, element, annotator);
return(fromAttributes.Concat(fromContentProperty).Concat(fromPropertyElements));
}
private MemberAssignment FromPropertyElement(Type type, XElement propertyElement, IPrefixAnnotator annotator)
{
var member = xmlTypeResolver.ResolveProperty(type, propertyElement);
var children = propertyElement.Elements().Select(e => createFunc(e, annotator)).ToList();
var directValue = GetDirectValue(propertyElement);
if (directValue != null && children.Any())
{
throw new Exception("Cannot have a direct value and child nodes at the same time");
}
return(new MemberAssignment {
Member = member, Values = children, SourceValue = directValue
});
}
private MemberAssignment FromPropertyElement(Type type, XElement propertyElement, IPrefixAnnotator annotator)
{
var member = resolver.ResolveProperty(type, propertyElement);
var children = propertyElement.Elements().Select(e => createFunc(e, annotator));
var directValue = GetDirectValue(propertyElement);
return(new MemberAssignment {
Member = member, Children = children, SourceValue = directValue
});
}
