private static Formplot?ReadFormplot(Stream metadataStream, Stream?pointDataStream, Version version, FormplotTypes[]?acceptedTypes)
{
using var reader = XmlReader.Create(metadataStream, CreateXmlReaderSettings());
reader.MoveToElement();
while (reader.Read() && reader.NodeType != XmlNodeType.EndElement)
{
if (reader.Name != FormplotRootTag && reader.Name != PropertiesRootTag)
{
continue;
}
if (!EnumParser <FormplotTypes> .TryParse(reader.GetAttribute("Type") ?? "", out var plotType))
{
plotType = FormplotTypes.None; // This code path is for Property Files (they don't have a form plot type)
}
if (acceptedTypes != null && !acceptedTypes.Contains(plotType))
{
return(null);
}
var targetVersion = FormplotHelper.GetFileFormatVersion(plotType);
if (version > targetVersion)
{
throw new NotSupportedException($"Invalid form plot file. Version {version} is not supported.");
}
return(CreateFormplot(pointDataStream, version, plotType, reader));
}
return(null);
}
public void Test_TryParse(string name, bool expectedParseResult, TestEnum expectedEnumValue)
{
// act
var parseResult = EnumParser <TestEnum> .TryParse(name, out var enumValue);
// assert
Assert.That(parseResult, Is.EqualTo(expectedParseResult));
Assert.That(enumValue, Is.EqualTo(expectedEnumValue));
}
/// <summary>
/// Deserializes the property data.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">reader</exception>
/// <exception cref="System.NotSupportedException"></exception>
internal static Property Deserialize(XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
var name = reader.GetAttribute("Name");
var dataType = EnumParser <DataTypeId> .TryParse(reader.GetAttribute("Type"), out var parsedDataType)
? parsedDataType
: DataTypeId.String; // Fall back to DataType = String for very old form plot data that might not have a data type identifier
var description = reader.GetAttribute("Description");
var unit = reader.GetAttribute("Unit");
var stringValue = reader.ReadString();
switch (dataType)
{
case DataTypeId.DateTime:
return(Create(name, XmlConvert.ToDateTime(stringValue, XmlDateTimeSerializationMode.RoundtripKind), description));
case DataTypeId.Double:
return(Create(name, XmlConvert.ToDouble(stringValue), description, unit));
case DataTypeId.Integer:
return(Create(name, XmlConvert.ToInt64(stringValue), description, unit));
case DataTypeId.String:
return(Create(name, stringValue, description));
case DataTypeId.TimeSpan:
return(Create(name, XmlConvert.ToTimeSpan(stringValue), description));
default:
throw new NotSupportedException($"DataTypeId \"{dataType}\" is not supported");
}
}
/// <summary>
/// Deserializes formplot data.
/// </summary>
/// <param name="metaDataReader">An XML reader to the header xml.</param>
/// <param name="pointDataStream">A stream of binary formplot point data.</param>
/// <returns></returns>
private static Formplot Deserialize(XmlReader metaDataReader, Stream pointDataStream)
{
if (metaDataReader == null)
{
throw new ArgumentNullException(nameof(metaDataReader));
}
var creatorSoftware = "unknown";
var creatorSoftwareVersion = new Version(0, 0);
var properties = new List <Property>();
var tolerance = default(Tolerance);
var defaultErrorScaling = default(double?);
var projectionAxis = ProjectionAxis.None;
var nominal = default(Geometry);
var actual = default(Geometry);
var points = default(Point[]);
Enum.TryParse(metaDataReader.GetAttribute("Type"), out FormplotTypes formplotType);
while (metaDataReader.Read() && metaDataReader.NodeType != XmlNodeType.EndElement)
{
switch (metaDataReader.Name)
{
case "CreatorSoftware":
creatorSoftware = metaDataReader.ReadString();
break;
case "CreatorSoftwareVersion":
creatorSoftwareVersion = new Version(metaDataReader.ReadString());
break;
case "Property":
properties.Add(Property.Deserialize(metaDataReader));
break;
case "Tolerance":
tolerance = Tolerance.Deserialize(metaDataReader);
break;
case "ErrorScaling":
defaultErrorScaling = XmlConvert.ToDouble(metaDataReader.ReadString());
break;
case "ProjectionAxis":
if (formplotType == FormplotTypes.Straightness)
{
projectionAxis = ( ProjectionAxis )Enum.Parse(typeof(ProjectionAxis), metaDataReader.ReadString());
}
else
{
throw new NotSupportedException("only straightness formplot data supports a projection axis");
}
break;
case "Geometry":
var geometryString = metaDataReader.GetAttribute("Type");
if (EnumParser <GeometryTypes> .TryParse(geometryString, out var geometryType))
{
if (geometryType != Geometry.GetGeometryTypeFromFormplotType(formplotType))
{
throw new NotSupportedException($"geometry type \"{geometryType}\" for plot type \"{formplotType}\" is not supported");
}
while (metaDataReader.Read() && metaDataReader.NodeType != XmlNodeType.EndElement)
{
switch (metaDataReader.Name)
{
case "Nominal":
nominal = Geometry.DeserializeGeometry(metaDataReader, geometryType);
break;
case "Actual":
actual = Geometry.DeserializeGeometry(metaDataReader, geometryType);
break;
}
}
}
else
{
throw new NotSupportedException($"geometry type \"{geometryString}\" is not supported");
}
break;
case "Points":
points = ReadPoints(formplotType, metaDataReader, pointDataStream);
break;
}
}
var plot = CreateFormplot(formplotType);
plot.CreatorSoftware = creatorSoftware;
plot.CreatorSoftwareVersion = creatorSoftwareVersion;
plot.Properties = properties.ToArray();
plot.Tolerance = tolerance;
plot.DefaultErrorScaling = defaultErrorScaling;
plot.ProjectionAxis = projectionAxis;
plot.Nominal = nominal;
plot.Actual = actual;
plot.Points = points;
return(plot);
}