481 lines
19 KiB
C#
481 lines
19 KiB
C#
/*
|
|
Test.cs
|
|
|
|
Copyright © 2008
|
|
Diversified Technical Systems, Inc.
|
|
All Rights Reserved
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Xml;
|
|
using System.Xml.Schema;
|
|
using System.Xml.Serialization;
|
|
using DTS.Utilities;
|
|
using DTS.Utilities.DotNetProgrammingConstructs;
|
|
using DTS.Utilities.Xml;
|
|
|
|
namespace DTS.Serialization
|
|
{
|
|
/// <summary>
|
|
/// Representation of a serializable test information.
|
|
/// </summary>
|
|
[XmlSerializationTag( "Test" )]
|
|
public partial class Test : Exceptional, IXmlSerializable
|
|
{
|
|
|
|
private Property<string> _software
|
|
= new Property<string>(typeof(Test).Namespace + ".Test.Software", "DataPRO", true);
|
|
[XmlSerializationTag("Software")]
|
|
public string Software
|
|
{
|
|
get { return _software.Value; }
|
|
set { _software.Value = value; }
|
|
}
|
|
|
|
private Property<string> _softwareVersion
|
|
= new Property<string>(typeof(Test).Namespace + ".Test.SoftwareVersion", "", false);
|
|
[XmlSerializationTag("SoftwareVersion")]
|
|
public string SoftwareVersion
|
|
{
|
|
get { return _softwareVersion.Value; }
|
|
set { _softwareVersion.Value = value; }
|
|
}
|
|
/*
|
|
/// <summary>
|
|
/// The string ID of this test.
|
|
/// </summary>
|
|
[XmlSerializationTag("Id")]
|
|
public string Id
|
|
{
|
|
get { return _Id.Value; }
|
|
set { _Id.Value = value; }
|
|
}
|
|
private Property<string> _Id
|
|
= new Property<string>(typeof(Test).Namespace + ".Test.Id", "", false);*/
|
|
// Initialize an instance of the Test class.
|
|
public Test()
|
|
{
|
|
TryGetChannelOrder();
|
|
//
|
|
// Note that the parameterless constructor for this object will leave
|
|
// the Id and Description paramters
|
|
} //
|
|
public Test(string dtsfile)
|
|
{
|
|
|
|
}
|
|
/// <summary>
|
|
/// Initialize an instance of the Test class.
|
|
/// </summary>
|
|
///
|
|
/// <param name="id">
|
|
/// The <see cref="string"/> ID of this test.
|
|
/// </param>
|
|
///
|
|
/// <param name="description">
|
|
/// The <see cref="string"/> description of this test.
|
|
/// </param>
|
|
///
|
|
public Test(string id, string description)
|
|
{
|
|
TryGetChannelOrder();
|
|
try
|
|
{
|
|
Id = id;
|
|
Description = description;
|
|
}
|
|
|
|
catch (System.Exception ex)
|
|
{
|
|
throw new Exception( "encountered problem constructing Test object (Id: " + ( !string.IsNullOrEmpty( id ) ? id : "<<NULL>>" ) + "Description: " + ( !string.IsNullOrEmpty( description ) ? description : "<<NULL>>" ) + ")", ex );
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the date of this object's serialization's creation (if applicable).
|
|
/// </summary>
|
|
public DateTime InceptionDate
|
|
{
|
|
get { return _InceptionDate.Value; }
|
|
set { _InceptionDate.Value = value; }
|
|
}
|
|
private Property<DateTime> _InceptionDate
|
|
= new Property<DateTime>(
|
|
typeof( Test ).Namespace + ".Test.InceptionDate",
|
|
DateTime.Now,
|
|
false
|
|
);
|
|
|
|
private Dictionary<string, int> _channelOrder = new Dictionary<string, int>();
|
|
|
|
private static string GetID(Test.Module.Channel channel)
|
|
{
|
|
if (null != channel.SensorID && channel.SensorID.Length > 0) { return channel.SensorID; }
|
|
else { return channel.ChannelDescriptionString; }
|
|
}
|
|
public class ChannelOrderComparor : IComparer<Test.Module.Channel>
|
|
{
|
|
private IDictionary<string, int> _dictionary;
|
|
|
|
public ChannelOrderComparor(IDictionary<string, int> dictionary)
|
|
{
|
|
_dictionary = dictionary;
|
|
}
|
|
public int Compare(Test.Module.Channel a, Test.Module.Channel b)
|
|
{
|
|
string keyA = GetID(a);
|
|
string keyB = GetID(b);
|
|
int iA = _dictionary.ContainsKey(keyA) ? _dictionary[keyA] : int.MaxValue;
|
|
int iB = _dictionary.ContainsKey(keyB) ? _dictionary[keyB] : int.MaxValue;
|
|
return iA.CompareTo(iB);
|
|
}
|
|
}
|
|
public void TryGetChannelOrder()
|
|
{
|
|
try
|
|
{
|
|
_channelOrder.Clear();
|
|
if (System.IO.File.Exists("ChannelOrder.txt"))
|
|
{
|
|
using (System.IO.StreamReader sr = new System.IO.StreamReader("ChannelOrder.txt"))
|
|
{
|
|
string line;
|
|
int i = 0;
|
|
while ((line = sr.ReadLine()) != null)
|
|
{
|
|
_channelOrder.Add(line, i++);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (System.Exception ex)
|
|
{
|
|
Utilities.Logging.APILogger.Log("Exception getting channel order", ex);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Get a named-DAS/numbered-channel accessor to this Event's channels.
|
|
/// </summary>
|
|
public List<Test.Module.Channel> Channels
|
|
{
|
|
get
|
|
{
|
|
try
|
|
{
|
|
if (_channelOrder.Count < 1) { TryGetChannelOrder(); }
|
|
List<Test.Module.Channel> allChannels = new List<Module.Channel>();
|
|
foreach (Test.Module testModule in this.Modules)
|
|
{
|
|
allChannels.AddRange(testModule.Channels);
|
|
allChannels.AddRange(testModule.CalculatedChannels);
|
|
}
|
|
allChannels.Sort(new Comparison<Module.Channel>(CompareChannels));
|
|
if (_channelOrder.Count > 0) { allChannels.Sort(new ChannelOrderComparor(_channelOrder)); }
|
|
return allChannels;
|
|
}
|
|
|
|
catch (System.Exception ex)
|
|
{
|
|
throw new Test.Exception("encountered problem getting all test channels", ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
private int CompareChannels(Test.Module.Channel left, Test.Module.Channel right)
|
|
{
|
|
if (left == right) { return 0; }
|
|
if (null == left) { return -1; }
|
|
if (null == right) { return 1; }
|
|
int ret = left.AbsoluteDisplayOrder.CompareTo(right.AbsoluteDisplayOrder);
|
|
if (0 == ret)
|
|
{
|
|
ret = left.ParentModule.Number.CompareTo(right.ParentModule.Number);
|
|
}
|
|
if (0 == ret)
|
|
{
|
|
return left.Number.CompareTo(right.Number);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
/// <summary>
|
|
/// The string ID of this test.
|
|
/// </summary>
|
|
[XmlSerializationTag( "Id" )]
|
|
public string Id
|
|
{
|
|
get { return _Id.Value; }
|
|
set { _Id.Value = value; }
|
|
}
|
|
private Property<string> _Id
|
|
= new Property<string>( typeof( Test ).Namespace + ".Test.Id", "", false);
|
|
|
|
/// <summary>
|
|
/// The string description of this test.
|
|
/// </summary>
|
|
[XmlSerializationTag( "Description" )]
|
|
public string Description
|
|
{
|
|
get { return _Description.Value; }
|
|
set { _Description.Value = value; }
|
|
}
|
|
private Property<string> _Description
|
|
= new Property<string>( typeof( Test ).Namespace + ".Test.Description", "", false );
|
|
|
|
/// <summary>
|
|
/// The globally unique identification string for this test.
|
|
/// </summary>
|
|
[XmlSerializationTag( "Guid" )]
|
|
public Guid Guid
|
|
{
|
|
get { return _Guid.Value; }
|
|
set { _Guid.Value = value; }
|
|
}
|
|
private Property<Guid> _Guid
|
|
= new Property<Guid>( typeof( Test ).Namespace + ".Test.Guid", new Guid( "00000000-0000-0000-0000-000000000000" ), false );
|
|
|
|
|
|
/// <summary>
|
|
/// The globally unique identification string for this test.
|
|
/// </summary>
|
|
[XmlSerializationTag("FaultFlags")]
|
|
public UInt16 FaultFlags
|
|
{
|
|
get { return _FaultFlags.Value; }
|
|
set { _FaultFlags.Value = value; }
|
|
}
|
|
private Property<UInt16> _FaultFlags
|
|
= new Property<UInt16>(typeof(Test).Namespace + ".Test.FaultFlags", 0, false);
|
|
|
|
/// <summary>
|
|
/// Get/set inline serialized data switch.
|
|
/// </summary>
|
|
[XmlSerializationTag( "InlineSerializedData" )]
|
|
public bool InlineSerializedData
|
|
{
|
|
get { return _InlineSerializedData.Value; }
|
|
set
|
|
{
|
|
try
|
|
{
|
|
_InlineSerializedData.Value = value;
|
|
foreach ( Test.Module module in Modules )
|
|
module.InlineSerializedData = value;
|
|
}
|
|
catch ( System.Exception ex )
|
|
{
|
|
throw new Exception( "encountered problem setting test InlineSerializedData state", ex );
|
|
}
|
|
}
|
|
}
|
|
private Property<bool> _InlineSerializedData
|
|
= new Property<bool>( typeof( Test ).Namespace + ".Test.InlineSerializedData", false, true );
|
|
|
|
/// <summary>
|
|
/// The list of modules in this test.
|
|
/// </summary>
|
|
[XmlSerializationTag( "Modules" )]
|
|
public List<Module> Modules
|
|
{
|
|
get { return _Modules.Value; }
|
|
set { _Modules.Value = value; }
|
|
}
|
|
private Property<List<Module>> _Modules
|
|
= new Property<List<Module>>( typeof( Test ).Namespace + ".Test.Modules", new List<Test.Module>( ), true );
|
|
|
|
/// <summary>
|
|
/// Write XML serialization for this object to the specified writer.
|
|
/// </summary>
|
|
///
|
|
/// <param name="writer">
|
|
/// The <see cref="XmlWriter"/> to which this object's XML serialization
|
|
/// will be written.
|
|
/// </param>
|
|
///
|
|
public void WriteXml( XmlWriter writer )
|
|
{
|
|
try
|
|
{
|
|
AttributeExtractor<XmlSerializationTagAttribute> attributeExtractor = new AttributeExtractor<XmlSerializationTagAttribute>( );
|
|
|
|
writer.WriteAttributeString( attributeExtractor.ExtractAttachedAttributeFromProperty( this, "Id" ).Value, this.Id );
|
|
writer.WriteAttributeString( attributeExtractor.ExtractAttachedAttributeFromProperty( this, "Description" ).Value, this.Description );
|
|
writer.WriteAttributeString( attributeExtractor.ExtractAttachedAttributeFromProperty( this, "InlineSerializedData" ).Value, this.InlineSerializedData.ToString( ) );
|
|
writer.WriteAttributeString( attributeExtractor.ExtractAttachedAttributeFromProperty( this, "Guid" ).Value, this.Guid.ToString( ) );
|
|
writer.WriteAttributeString(attributeExtractor.ExtractAttachedAttributeFromProperty(this, "FaultFlags").Value, this.FaultFlags.ToString());
|
|
|
|
writer.WriteAttributeString(attributeExtractor.ExtractAttachedAttributeFromProperty(this, "Software").Value, this.Software.ToString());
|
|
writer.WriteAttributeString(attributeExtractor.ExtractAttachedAttributeFromProperty(this, "SoftwareVersion").Value, this.SoftwareVersion.ToString());
|
|
|
|
writer.WriteStartElement ( attributeExtractor.ExtractAttachedAttributeFromProperty( this, "Modules" ).Value );
|
|
|
|
foreach (var module in Modules)
|
|
{
|
|
module.WriteXml(writer);
|
|
}
|
|
|
|
writer.WriteEndElement();
|
|
}
|
|
|
|
catch ( System.Exception ex )
|
|
{
|
|
throw new Exception( "encountered problem converting DTS.Serialization.Test object to XML", ex );
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read XML serialization for this object from the specified reader.
|
|
/// </summary>
|
|
///
|
|
/// <param name="reader">
|
|
/// The <see cref="XmlReader"/> from which this object's XML serialization
|
|
/// will be read.
|
|
/// </param>
|
|
///
|
|
public void ReadXml( XmlReader reader )
|
|
{
|
|
try
|
|
{
|
|
AttributeExtractor<XmlSerializationTagAttribute> attributeExtractor = new AttributeExtractor<XmlSerializationTagAttribute>();
|
|
|
|
if (reader.IsStartElement("Test"))
|
|
{
|
|
this.Id = reader.GetAttribute(attributeExtractor.ExtractAttachedAttributeFromProperty(this, "Id").Value);
|
|
this.Description = reader.GetAttribute(attributeExtractor.ExtractAttachedAttributeFromProperty(this, "Description").Value);
|
|
this.InlineSerializedData = bool.Parse(reader.GetAttribute(attributeExtractor.ExtractAttachedAttributeFromProperty(this, "InlineSerializedData").Value));
|
|
|
|
try { this.Guid = new Guid(reader.GetAttribute(attributeExtractor.ExtractAttachedAttributeFromProperty(this, "Guid").Value)); }
|
|
catch (System.Exception) { this.Guid = new Guid("00000000-0000-0000-0000-000000000000"); }
|
|
|
|
try { this.FaultFlags = Convert.ToUInt16(reader.GetAttribute(attributeExtractor.ExtractAttachedAttributeFromProperty(this, "FaultFlags").Value)); }
|
|
catch (System.Exception) { this.FaultFlags = 0; }
|
|
|
|
try { this.Software = reader.GetAttribute(attributeExtractor.ExtractAttachedAttributeFromProperty(this, "Software").Value); }
|
|
catch (System.Exception) { Software = "unknown"; }
|
|
|
|
try { this.SoftwareVersion = reader.GetAttribute(attributeExtractor.ExtractAttachedAttributeFromProperty(this, "SoftwareVersion").Value); }
|
|
catch (System.Exception) { SoftwareVersion = "unknown"; }
|
|
|
|
this.Modules.Clear();
|
|
|
|
if (reader.ReadToDescendant("Modules"))
|
|
{
|
|
if (reader.ReadToDescendant("Module"))
|
|
{
|
|
do
|
|
{
|
|
Test.Module deserializedModule = new Test.Module(this);
|
|
deserializedModule.InlineSerializedData = InlineSerializedData;
|
|
|
|
//Give the deserializer a separate reader so that it can't go amuck and read past the current module.
|
|
deserializedModule.ReadXml(reader.ReadSubtree());
|
|
this.Modules.Add(deserializedModule);
|
|
}
|
|
while (reader.ReadToNextSibling("Module"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (System.Exception ex)
|
|
{
|
|
throw new Exception("encountered problem converting XML to DTS.Serialization.Test object", ex);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Should normally return a schema representing the form of the XML
|
|
/// generated/consumed by WriteXml/ReadXml, but it never called during
|
|
/// the serialization process so ours just returns null.
|
|
/// </summary>
|
|
///
|
|
/// <returns>
|
|
/// Null <see cref="XmlSchema"/> reference, always.
|
|
/// </returns>
|
|
///
|
|
public XmlSchema GetSchema( )
|
|
{
|
|
// This method is never invoked during XML object serialization.
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Test the specified object for equality with this object.
|
|
/// </summary>
|
|
///
|
|
/// <param name="obj">
|
|
/// The <see cref="object"/> to be tested for equality.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// <see cref="bool"/> true if the specified object has memeberwise equality with
|
|
/// this object; false otherwise.
|
|
/// </returns>
|
|
///
|
|
public override bool Equals( object obj )
|
|
{
|
|
try
|
|
{
|
|
Test that = obj as Test;
|
|
return null != that
|
|
&& this.Id.Equals( that.Id )
|
|
&& this.Description.Equals( that.Description )
|
|
&& this.ModulesEquals( that.Modules );
|
|
}
|
|
|
|
catch ( System.Exception ex )
|
|
{
|
|
throw new Exception( "encountered problem equality testing object " + ( null != obj ? "\"" + obj.ToString( ) + "\"" : "<<NULL>>" ), ex );
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Test the specified object's module list for equality with this object's
|
|
/// module list.
|
|
/// </summary>
|
|
///
|
|
/// <param name="thoseModules">
|
|
/// The <see cref="List"/> of <see cref="Dts.Serialization.Test"/> object to be
|
|
/// compared for equality with this test's equivalent.
|
|
/// </param>
|
|
///
|
|
/// <returns>
|
|
/// <see cref="bool"/> true if the two lists contain equivalent-valued members;
|
|
/// false otherwise.
|
|
/// </returns>
|
|
///
|
|
private bool ModulesEquals( List<Test.Module> thoseModules )
|
|
{
|
|
try
|
|
{
|
|
if ( this.Modules.Count != thoseModules.Count )
|
|
return false;
|
|
else for ( int i=0; i < thoseModules.Count; i++ )
|
|
if ( !this.Modules[ i ].Equals( thoseModules[ i ] ) )
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
catch ( System.Exception ex )
|
|
{
|
|
throw new Exception( "encountered problem equality-testing module list", ex );
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return the hash code for this object.
|
|
/// </summary>
|
|
///
|
|
/// <returns>
|
|
/// The <see cref="int"/> hash code for this object.
|
|
/// </returns>
|
|
///
|
|
public override int GetHashCode( )
|
|
{
|
|
return base.GetHashCode( );
|
|
}
|
|
}
|
|
}
|