private bool Validate(ParsedNode node, NodeProcessor nodeProcessor, DocumentProcessorState state)
{
bool validateAttributesResult = ValidateProperties(node, node.AttributeBag, nodeProcessor.AttributeDefinitions, nodeProcessor.IgnoredAttributeNames, state);
bool validatePropertiesResult = ValidateProperties(node, node.PropertyBag, nodeProcessor.PropertyDefinitions, nodeProcessor.IgnoredPropertyNames, state);
return(validateAttributesResult && validatePropertiesResult);
}
private Node ProcessNode(ParsedNode node, DocumentProcessorState state)
{
if (IsIgnoredNode(node))
{
return(null);
}
NodeProcessor nodeProcessor = FindProcessorForNode(node);
if (null == nodeProcessor)
{
state.AddWarning("Processor not found (sectionType={0}, {1})", node.SectionType, node.AttributeBag.ToString());
return(null);
}
if (!Validate(node, nodeProcessor, state))
{
return(null);
}
List <Node> children = new List <Node>();
foreach (ParsedNode childNode in node.Children.Nodes)
{
Node child = ProcessNode(childNode, state);
if (null != child)
{
children.Add(child);
}
}
return(nodeProcessor.Convert(node, children.ToArray()));
}
public DocumentProcessorResult <T> Convert(ParsedDocument document)
{
ParsedNode rootNode = document.RootNode;
DocumentProcessorState state = new DocumentProcessorState();
T convertedRootNode = ProcessNode(rootNode, state) as T;
return(new DocumentProcessorResult <T>(convertedRootNode, state.Problems));
}
private bool ValidateProperties(ParsedNode node, ParsedPropertyBag propertyBag, PropertyDefinition[] propertyDefinitions, string[] ignoredPropertyNames, DocumentProcessorState state)
{
bool presenceValidationResult = ValidatePresenceOfProperties(node.FindAttributeValue("Name"), propertyBag, propertyDefinitions, ignoredPropertyNames, state);
bool valueValidationResult = ValidatePropertiesValues(node.FindAttributeValue("Name"), propertyBag, propertyDefinitions, state);
return(presenceValidationResult && valueValidationResult);
}
private bool ValidatePropertyValue(string nodeName, ParsedProperty parsedProperty, PropertyDefinition propertyDefinition, DocumentProcessorState state, bool testForArray = true)
{
bool wasValid = false;
if (testForArray && propertyDefinition.IsArray)
{
if (!parsedProperty.IsArray)
{
wasValid = false;
state.AddError($"Property \"{propertyDefinition.Name}\" on \"{nodeName}\" was expected to be an array but got something else");
return(false);
}
else
{
wasValid = true;
foreach (var parsedPropertyElement in parsedProperty.Elements)
{
if (!ValidatePropertyValue(nodeName, parsedPropertyElement, propertyDefinition, state, false))
{
wasValid = false;
}
}
}
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.AttributeList))
{
ValueUtil.TryParseAttributeList(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.BlendMode))
{
ValueUtil.TryParseBlendMode(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.DecalBlendMode))
{
ValueUtil.TryParseDecalBlendMode(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.Boolean))
{
ValueUtil.TryParseBoolean(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.ExpressionReference))
{
ValueUtil.TryParseExpressionReference(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.Float))
{
ValueUtil.TryParseFloat(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.FunctionReference))
{
ValueUtil.TryParseFunctionReference(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.Integer))
{
ValueUtil.TryParseInteger(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.MaterialDomain))
{
ValueUtil.TryParseMaterialDomain(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.SamplerType))
{
ValueUtil.TryParseSamplerType(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.ShadingModel))
{
ValueUtil.TryParseShadingModel(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.String))
{
wasValid = true;
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.ResourceReference))
{
ValueUtil.TryParseResourceReference(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.TranslucencyLightingMode))
{
ValueUtil.TryParseTranslucencyLightingMode(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.Rotator))
{
ValueUtil.TryParseRotator(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.Mobility))
{
ValueUtil.TryParseMobility(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.WorldPositionIncludedOffsets))
{
ValueUtil.TryParseWorldPositionIncludedOffsets(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.MaterialSceneAttributeInputMode))
{
ValueUtil.TryParseMaterialSceneAttributeInputMode(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.SceneTextureId))
{
ValueUtil.TryParseSceneTextureId(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.MaterialVectorCoordTransformSource))
{
ValueUtil.TryParseMaterialVectorCoordTransformSource(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.MaterialVectorCoordTransform))
{
ValueUtil.TryParseMaterialVectorCoordTransform(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.Vector2))
{
ValueUtil.TryParseVector2(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.Vector3))
{
ValueUtil.TryParseVector3(parsedProperty.Value, out wasValid);
}
else if (propertyDefinition.DataType.HasFlag(PropertyDataType.Vector4))
{
ValueUtil.TryParseVector4(parsedProperty.Value, out wasValid);
}
else
{
state.AddError($"Property \"{parsedProperty.Name} on \"{nodeName}\" had unhandled data type: {propertyDefinition.DataType}");
return(false);
}
if (!wasValid)
{
state.AddError($"Property \"{parsedProperty.Name}\" on \"{nodeName}\" value is invalid: {parsedProperty.Value}");
}
return(wasValid);
}
private bool ValidatePropertiesValues(string nodeName, ParsedPropertyBag propertyBag, PropertyDefinition[] propertyDefinitions, DocumentProcessorState state)
{
bool hasProblems = false;
foreach (PropertyDefinition propertyDefinition in propertyDefinitions)
{
ParsedProperty parsedProperty = propertyBag.FindProperty(propertyDefinition.Name);
if (null == parsedProperty)
{
continue;
}
if (!ValidatePropertyValue(nodeName, parsedProperty, propertyDefinition, state))
{
hasProblems = true;
}
}
return(!hasProblems);
}
private bool ValidatePresenceOfProperties(string nodeName, ParsedPropertyBag propertyBag, PropertyDefinition[] propertyDefinitions, string[] ignoredPropertyNames, DocumentProcessorState state)
{
IEnumerable <string> providedKeys = propertyBag.Properties.Select(property => property.Name);
IEnumerable <string> allDefinedKeys = propertyDefinitions.Select(property => property.Name);
IEnumerable <string> requiredDefinedKeys = propertyDefinitions.Where(attribute => attribute.IsRequired).Select(property => property.Name);
string[] missingPropertiesInMaterial = providedKeys.Except(allDefinedKeys).ToList().Except(ignoredPropertyNames).ToArray();
string[] missingRequiredProperties = requiredDefinedKeys.Except(providedKeys).ToArray();
foreach (string s in missingPropertiesInMaterial)
{
state.AddWarning("Unknown property found (property={0}, node={1})", s, nodeName);
}
foreach (string s in missingRequiredProperties)
{
state.AddError("Required property is missing (property={0}, node={1})", s, nodeName);
}
return(missingRequiredProperties.Length == 0);
}
