367 lines
16 KiB
C#
367 lines
16 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.IO;
|
|
using System.Xml.Serialization;
|
|
using System.Xml;
|
|
using System.Xml.Schema;
|
|
using DTS.Common.XMLUtils;
|
|
|
|
namespace DTS.Common.ISO
|
|
{
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Minor Code Smell", "S101:Types should be named in PascalCase", Justification = "Acronym")]
|
|
public class MMETestObjectWrapper : IXmlSerializable
|
|
{
|
|
/// <summary>
|
|
/// part of IXmlSerializable - from MS documentation this should return null
|
|
/// when implementing IXmlSerializable
|
|
/// https://learn.microsoft.com/en-us/dotnet/api/system.xml.serialization.ixmlserializable.getschema?view=net-9.0
|
|
/// </summary>
|
|
public XmlSchema GetSchema()
|
|
{
|
|
return null;
|
|
}
|
|
/// <summary>
|
|
/// writes an element with a text value into xml
|
|
/// this is used for adding properties into the xml body for the class
|
|
/// </summary>
|
|
private void WriteField(XmlWriter writer, string field, string value)
|
|
{
|
|
if (null == writer) { throw new ArgumentException("MMETestObjectWrapper::WriteField - writer was null"); }
|
|
if (string.IsNullOrEmpty(field)) { return; } //nothing to add
|
|
writer.WriteStartElement(field);
|
|
writer.WriteString(value);
|
|
writer.WriteEndElement();
|
|
}
|
|
/// <summary>
|
|
/// serializes class to xml
|
|
/// </summary>
|
|
public void WriteXml(XmlWriter writer)
|
|
{
|
|
if (null == writer)
|
|
{
|
|
throw new ArgumentException("MMETestObjectWrapper::WriteXml - XmlWriter was null");
|
|
}
|
|
writer.WriteStartElement("TestObject");
|
|
WriteField(writer, "BarrierHeightOfTestObject", BarrierHeightOfTestObject);
|
|
WriteField(writer, "BarrierWidthOfTestObject", BarrierWidthOfTestObject);
|
|
WriteField(writer, "ClassOfTestObject", ClassOfTestObject);
|
|
WriteField(writer, "CodeOfTestObject", CodeOfTestObject);
|
|
WriteField(writer, "DriverPosition", DriverPosition);
|
|
WriteField(writer, "File", File);
|
|
WriteField(writer, "ImpactSide", ImpactSide);
|
|
WriteField(writer, "MMETestObjectGUID", MMETestObjectGUID);
|
|
WriteField(writer, "MassOfTestObject", MassOfTestObject);
|
|
WriteField(writer, "Name", Name);
|
|
WriteField(writer, "NumberOfLoadcellsOfTestObject", NumberOfLoadcellsOfTestObject);
|
|
WriteField(writer, "OffsetOfTestObject", OffsetOfTestObject);
|
|
WriteField(writer, "OriginXOfTestObject", OriginXOfTestObject);
|
|
WriteField(writer, "OriginYOfTestObject", OriginYOfTestObject);
|
|
WriteField(writer, "OriginZOfTestObject", OriginZOfTestObject);
|
|
WriteField(writer, "ReferenceNumberOfTestObject", ReferenceNumberOfTestObject);
|
|
WriteField(writer, "ReferenceSystemOfTestObject", ReferenceSystemOfTestObject);
|
|
WriteField(writer, "TypeOfTestObject", TypeOfTestObject);
|
|
WriteField(writer, "Velocity", Velocity);
|
|
WriteField(writer, "VelocityMeasurementUnit", VelocityMeasurementUnit);
|
|
WriteField(writer, "YawAngleOfTestObject", YawAngleOfTestObject);
|
|
|
|
WriteComments(writer);
|
|
WriteISOTestObjectChannels(writer);
|
|
|
|
WriteExtraProperties(writer);
|
|
writer.WriteEndElement();
|
|
}
|
|
private void WriteISOTestObjectChannels(XmlWriter writer)
|
|
{
|
|
if (null == writer) { throw new ArgumentException("MMETestObjectWrapper::WriteISOTestObjectChannels - writer was null"); }
|
|
writer.WriteStartElement("Channels");
|
|
|
|
if (null != ISOTestObjectChannels)
|
|
{
|
|
foreach (var channel in ISOTestObjectChannels)
|
|
{
|
|
writer.WriteStartElement("Channel");
|
|
writer.WriteString(channel);
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
writer.WriteEndElement();
|
|
}
|
|
private void ReadISOTestObjectChannels(XmlReader reader)
|
|
{
|
|
if (null == reader) { throw new ArgumentException("MMETestObjectWrapper::ReadISOTestObjectChannels - reader was null"); }
|
|
var channels = new List<string>();
|
|
//if the element tag is empty there's nothing else to process, move to next node
|
|
if (reader.Name == "Channels" && reader.IsEmptyElement) { reader.Read(); }
|
|
else
|
|
{
|
|
reader.ReadStartElement("Channels");
|
|
|
|
while (reader.IsStartElement() && reader.Name == "Channel")
|
|
{
|
|
channels.Add(DTSXMLFile.GetInnerXML(reader));
|
|
reader.Read();
|
|
}
|
|
|
|
ISOTestObjectChannels = channels.ToArray();
|
|
|
|
reader.ReadEndElement();
|
|
}
|
|
}
|
|
private void ReadComments(XmlReader reader)
|
|
{
|
|
if (null == reader) { throw new ArgumentException("MMETestObjectWrapper::ReadComments - XmlReader was null"); }
|
|
var comments = new List<string>();
|
|
//if top level element is empty, nothing to process, just move to next node
|
|
if (reader.IsEmptyElement && reader.Name == "Comments") { reader.Read(); }
|
|
else
|
|
{
|
|
reader.ReadStartElement("Comments");
|
|
|
|
while( reader.IsStartElement() && reader.Name == "Comment")
|
|
{
|
|
comments.Add(DTSXMLFile.GetInnerXML(reader));
|
|
}
|
|
|
|
reader.ReadEndElement();
|
|
}
|
|
Comments = comments.ToArray();
|
|
}
|
|
private void WriteComments(XmlWriter writer)
|
|
{
|
|
if (null == writer) { throw new ArgumentException("MMETestObjectWrapper::WriteComments - XmlWriter was null"); }
|
|
writer.WriteStartElement("Comments");
|
|
foreach( var comment in Comments)
|
|
{
|
|
writer.WriteStartElement("Comment");
|
|
writer.WriteString(comment);
|
|
writer.WriteEndElement();
|
|
}
|
|
writer.WriteEndElement();
|
|
}
|
|
private void ReadExtraProperties(XmlReader reader)
|
|
{
|
|
if (null == reader) { throw new ArgumentException("MMETestObjectWrapper::ReadExtraProperties - XmlReader was null"); }
|
|
var list = new List<KeyValuePair<string, string>>();
|
|
if (reader.Name == "ExtraProperties" && reader.IsEmptyElement) { reader.Read(); }
|
|
else
|
|
{
|
|
reader.ReadStartElement("ExtraProperties");
|
|
|
|
while (reader.IsStartElement() && reader.Name == "ExtraProperty")
|
|
{
|
|
var key = reader.GetAttribute("Key");
|
|
var value = reader.GetAttribute("Value");
|
|
list.Add(new KeyValuePair<string, string>(key, value));
|
|
reader.Read();
|
|
}
|
|
|
|
reader.ReadEndElement();
|
|
}
|
|
ExtraProperties = list.ToArray();
|
|
}
|
|
private void WriteExtraProperties(XmlWriter writer)
|
|
{
|
|
if (null == writer) { throw new ArgumentException("MMETestObjectWrapper::WriteExtraProperties - XmlWriter was null"); }
|
|
writer.WriteStartElement("ExtraProperties");
|
|
|
|
if (null != ExtraProperties)
|
|
{
|
|
foreach( var kvp in ExtraProperties)
|
|
{
|
|
writer.WriteStartElement("ExtraProperty");
|
|
|
|
writer.WriteAttributeString("Key", kvp.Key);
|
|
writer.WriteAttributeString("Value", kvp.Value);
|
|
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
|
|
writer.WriteEndElement();
|
|
}
|
|
|
|
public void ReadXml(XmlReader reader)
|
|
{
|
|
if (null == reader) { throw new ArgumentException("MMETestObjectWrapper::ReadXml - XmlReader was null"); }
|
|
reader.ReadStartElement("TestObject");
|
|
while (reader.IsStartElement())
|
|
{
|
|
switch (reader.Name)
|
|
{
|
|
case "BarrierHeightOfTestObject":
|
|
BarrierHeightOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "BarrierWidthOfTestObject":
|
|
BarrierWidthOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "ClassOfTestObject":
|
|
ClassOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "CodeOfTestObject":
|
|
CodeOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "DriverPosition":
|
|
DriverPosition = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "File":
|
|
File = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "ImpactSide":
|
|
ImpactSide = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "MMETestObjectGUID":
|
|
MMETestObjectGUID = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "MassOfTestObject":
|
|
MassOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "Name":
|
|
Name = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "NumberOfLoadcellsOfTestObject":
|
|
NumberOfLoadcellsOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "OffsetOfTestObject":
|
|
OffsetOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "OriginXOfTestObject":
|
|
OriginXOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "OriginYOfTestObject":
|
|
OriginYOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "OriginZOfTestObject":
|
|
OriginZOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "ReferenceNumberOfTestObject":
|
|
ReferenceNumberOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "ReferenceSystemOfTestObject":
|
|
ReferenceSystemOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "TypeOfTestObject":
|
|
TypeOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "Velocity":
|
|
Velocity = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "VelocityMeasurementUnit":
|
|
VelocityMeasurementUnit = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "YawAngleOfTestObject":
|
|
YawAngleOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
|
|
case "Comments":
|
|
ReadComments(reader);
|
|
break;
|
|
case "Channels":
|
|
ReadISOTestObjectChannels(reader);
|
|
break;
|
|
case "ExtraProperties":
|
|
ReadExtraProperties(reader);
|
|
break;
|
|
default:
|
|
throw new ArgumentException($"MMETestObjectWrapper::ReadXml - invalid node - {reader.Name}");
|
|
}
|
|
}
|
|
//end of TestObject element
|
|
reader.ReadEndElement();
|
|
}
|
|
public string GetDirectory() { return "Test Objects"; }
|
|
|
|
public string BarrierHeightOfTestObject { get; set; } = "NOVALUE";
|
|
|
|
public string BarrierWidthOfTestObject { get; set; } = "NOVALUE";
|
|
|
|
public string ClassOfTestObject { get; set; } = "NOVALUE";
|
|
|
|
public string CodeOfTestObject { get; set; } = "NOVALUE";
|
|
|
|
public string[] Comments { get; set; } = new string[0];
|
|
|
|
public string DriverPosition { get; set; } = "NOVALUE";
|
|
|
|
public string File { get; set; } = "Not Saved Yet";
|
|
|
|
public string ImpactSide { get; set; } = "NOVALUE";
|
|
|
|
public string[] ISOTestObjectChannels { get; set; }
|
|
|
|
public string MMETestObjectGUID { get; set; } = "";
|
|
|
|
public string MassOfTestObject { get; set; } = "NOVALUE";
|
|
|
|
public string Name { get; set; } = "NOVALUE";
|
|
|
|
public string NumberOfLoadcellsOfTestObject { get; set; } = "NOVALUE";
|
|
|
|
public string OffsetOfTestObject { get; set; } = "NOVALUE";
|
|
|
|
public string OriginXOfTestObject { get; set; } = "NOVALUE";
|
|
|
|
public string OriginYOfTestObject { get; set; } = "NOVALUE";
|
|
|
|
public string OriginZOfTestObject { get; set; } = "NOVALUE";
|
|
|
|
public string ReferenceNumberOfTestObject { get; set; } = "NOVALUE";
|
|
|
|
public string ReferenceSystemOfTestObject { get; set; } = "NOVALUE";
|
|
|
|
public string TypeOfTestObject { get; set; } = "NOVALUE";
|
|
|
|
public string Velocity { get; set; } = "NOVALUE";
|
|
|
|
public string VelocityMeterPerSecond => ConvertVelocityToMeterPerSecond(Velocity, VelocityMeasurementUnit);
|
|
|
|
public string VelocityMeasurementUnit { get; set; } = "NOVALUE";
|
|
|
|
public string YawAngleOfTestObject { get; set; } = "NOVALUE";
|
|
|
|
/// <summary>
|
|
/// Convert Velocity to m/sec unit
|
|
/// </summary>
|
|
/// <param name="velocity"></param>
|
|
/// <param name="velocityUnit">VelocityUnit enum index</param>
|
|
/// <returns>Velocity in m/sec</returns>
|
|
private string ConvertVelocityToMeterPerSecond(string velocity, string velocityUnit)
|
|
{
|
|
if (velocity == "NOVALUE" || velocityUnit == "NOVALUE")
|
|
{
|
|
return velocity;
|
|
}
|
|
|
|
if ((DTS.Common.Enums.VelocityUnit)Convert.ToInt32(velocityUnit) == Enums.VelocityUnit.KilometerPerHour)
|
|
{
|
|
return (Convert.ToDouble(velocity) / 3.6).ToString();
|
|
}
|
|
return velocity;
|
|
}
|
|
|
|
public KeyValuePair<string, string>[] ExtraProperties { get; set; } = new KeyValuePair<string, string>[0];
|
|
|
|
|
|
public MMETestObjectWrapper()
|
|
{
|
|
}
|
|
|
|
public MMETestObjectWrapper(string location)
|
|
{
|
|
if (!location.Contains(Path.DirectorySeparatorChar) && !location.Contains(Path.AltDirectorySeparatorChar))
|
|
{
|
|
var dir = Path.Combine(Environment.CurrentDirectory, GetDirectory());
|
|
location = Path.Combine(dir, location);
|
|
}
|
|
File = location;
|
|
var serializer = new XmlSerializer(typeof(MMETestObjectWrapper));
|
|
using (TextReader tr = new StreamReader(location))
|
|
{
|
|
var cd = (MMETestObjectWrapper)serializer.Deserialize(tr);
|
|
ClassOfTestObject = cd.ClassOfTestObject;
|
|
CodeOfTestObject = cd.CodeOfTestObject;
|
|
Comments = cd.Comments;
|
|
DriverPosition = cd.DriverPosition;
|
|
ExtraProperties = cd.ExtraProperties;
|
|
File = cd.File;
|
|
ImpactSide = cd.ImpactSide;
|
|
MassOfTestObject = cd.MassOfTestObject;
|
|
MMETestObjectGUID = cd.MMETestObjectGUID;
|
|
Name = cd.Name;
|
|
ReferenceNumberOfTestObject = cd.ReferenceNumberOfTestObject;
|
|
Velocity = cd.Velocity;
|
|
VelocityMeasurementUnit = cd.VelocityMeasurementUnit;
|
|
OffsetOfTestObject = cd.OffsetOfTestObject;
|
|
BarrierWidthOfTestObject = cd.BarrierWidthOfTestObject;
|
|
BarrierHeightOfTestObject = cd.BarrierHeightOfTestObject;
|
|
YawAngleOfTestObject = cd.YawAngleOfTestObject;
|
|
ReferenceSystemOfTestObject = cd.ReferenceSystemOfTestObject;
|
|
OriginXOfTestObject = cd.OriginXOfTestObject;
|
|
OriginYOfTestObject = cd.OriginYOfTestObject;
|
|
OriginZOfTestObject = cd.OriginZOfTestObject;
|
|
NumberOfLoadcellsOfTestObject = cd.NumberOfLoadcellsOfTestObject;
|
|
|
|
tr.Close();
|
|
}
|
|
}
|
|
}
|
|
}
|