private static XmlDocument Serialize(IGraphable graph)
{
using (var ms = new MemoryStream())
using (var xmlWriter = XmlWriter.Create(ms, new XmlWriterSettings { Indent = true }))
using (var xsw = new XmlStateWriter(xmlWriter))
{
var structureFormatter = CreateStructureFormater();
xsw.WriteStartElement("ClinicalDocument", "urn:hl7-org:v3");
xsw.WriteAttributeString("xmlns", "xsi", null, XmlIts1Formatter.NS_XSI);
xsw.WriteAttributeString("xmlns", null, null, "urn:hl7-org:v3");
xsw.WriteAttributeString("xmlns", "custom", null, CustomNamespace);
xsw.WriteAttributeString("xsi", "type", XmlIts1Formatter.NS_XSI, "custom:ClinicalDocument");
structureFormatter.Graph(xsw, graph);
xsw.Close();
ms.Seek(0, SeekOrigin.Begin);
Debug.WriteLine(Encoding.UTF8.GetString(ms.ToArray()));
using (var reader = new XmlTextReader(ms))
{
var result = new XmlDocument();
result.Load(reader);
return result;
}
}
}
public void UVPEqualsSerializationTest()
{
MARC.Everest.DataTypes.UVP<MARC.Everest.DataTypes.INT> aValue = new MARC.Everest.DataTypes.UVP<MARC.Everest.DataTypes.INT>(), bValue = null;
aValue.Probability = (decimal)0.0f;
aValue.Value = new MARC.Everest.DataTypes.INT(0);
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.UVP<MARC.Everest.DataTypes.INT>>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.UVP<MARC.Everest.DataTypes.INT>)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void TELEqualsSerializationTest()
{
MARC.Everest.DataTypes.TEL aValue = new MARC.Everest.DataTypes.TEL(), bValue = null;
aValue.Use = new MARC.Everest.DataTypes.SET<MARC.Everest.DataTypes.CS<MARC.Everest.DataTypes.Interfaces.TelecommunicationAddressUse>>(0) { new MARC.Everest.DataTypes.CS<MARC.Everest.DataTypes.Interfaces.TelecommunicationAddressUse>(MARC.Everest.DataTypes.Interfaces.TelecommunicationAddressUse.Home) };
aValue.UseablePeriod = new MARC.Everest.DataTypes.GTS(new MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.TS>(new MARC.Everest.DataTypes.TS(DateTime.Parse("2011-1-10"))));
aValue.Value = "0";
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.TEL>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.TEL)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void ADXPEqualsSerializationTest()
{
MARC.Everest.DataTypes.ADXP aValue = new MARC.Everest.DataTypes.ADXP(), bValue = null;
aValue.Value = "0";
aValue.Code = "0";
aValue.Type = new System.Nullable<MARC.Everest.DataTypes.AddressPartType>(MARC.Everest.DataTypes.AddressPartType.AddressLine);
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.ADXP>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.ADXP)).Structure);
bValue.Type = MARC.Everest.DataTypes.AddressPartType.AddressLine;
Assert.AreEqual(aValue, bValue);
}
public void EIVLEqualsSerializationTest()
{
MARC.Everest.DataTypes.EIVL<MARC.Everest.DataTypes.INT> aValue = new MARC.Everest.DataTypes.EIVL<MARC.Everest.DataTypes.INT>(), bValue = null;
aValue.Event = new MARC.Everest.DataTypes.CS<MARC.Everest.DataTypes.DomainTimingEventType>(MARC.Everest.DataTypes.DomainTimingEventType.BeforeMeal);
aValue.Offset = new MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.PQ>(new MARC.Everest.DataTypes.PQ((decimal)0, "0"));
aValue.Operator = new System.Nullable<MARC.Everest.DataTypes.SetOperator>(MARC.Everest.DataTypes.SetOperator.Hull);
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.EIVL<MARC.Everest.DataTypes.INT>>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.EIVL<MARC.Everest.DataTypes.INT>)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void ENEqualsSerializationTest()
{
MARC.Everest.DataTypes.EN aValue = new MARC.Everest.DataTypes.EN(), bValue = null;
aValue.Use = new MARC.Everest.DataTypes.SET<MARC.Everest.DataTypes.CS<MARC.Everest.DataTypes.EntityNameUse>>(MARC.Everest.DataTypes.EntityNameUse.Legal);
aValue.Flavor = "0";
aValue.Part.Add(new MARC.Everest.DataTypes.ENXP("Bob", MARC.Everest.DataTypes.EntityNamePartType.Given));
aValue.Part.Add(new MARC.Everest.DataTypes.ENXP("Dole", MARC.Everest.DataTypes.EntityNamePartType.Family));
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.EN>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.EN)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void COEqualsSerializationTest()
{
MARC.Everest.DataTypes.CO aValue = new MARC.Everest.DataTypes.CO(), bValue = null;
aValue.OriginalText = new MARC.Everest.DataTypes.ED(new System.Byte[] { 0 }, "0");
aValue.Code = new MARC.Everest.DataTypes.CD<System.String>("0");
aValue.Code.CodeSystem = "0";
aValue.Code.CodeSystemName = "0";
aValue.Code.CodeSystemVersion = "0";
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.CO>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.CO)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void IVLInclusiveFormattingTest()
{
IVL<INT> intIvl = new IVL<INT>(1, 4);
intIvl.LowClosed = true;
intIvl.HighClosed = false;
MemoryStream ms = new MemoryStream();
XmlStateWriter writer = new XmlStateWriter(XmlWriter.Create(ms));
writer.WriteStartElement("ivl", "urn:hl7-org:v3");
MARC.Everest.Formatters.XML.Datatypes.R1.DatatypeFormatter fmtr = new MARC.Everest.Formatters.XML.Datatypes.R1.DatatypeFormatter();
fmtr.Graph(writer, intIvl);
writer.Close();
ms.Seek(0, SeekOrigin.Begin);
XmlDocument d = new XmlDocument();
d.Load(ms);
Tracer.Trace(d.OuterXml);
Assert.IsTrue(d.OuterXml.Contains("inclusive"));
}
public void EDEqualsSerializationTest()
{
MARC.Everest.DataTypes.ED aValue = new MARC.Everest.DataTypes.ED(), bValue = null;
aValue.Data = new System.Byte[] { 0 };
aValue.Compression = new System.Nullable<MARC.Everest.DataTypes.Interfaces.EncapsulatedDataCompression>(MARC.Everest.DataTypes.Interfaces.EncapsulatedDataCompression.DF);
aValue.Representation = MARC.Everest.DataTypes.Interfaces.EncapsulatedDataRepresentation.TXT;
aValue.Language = "0";
aValue.MediaType = "0";
aValue.IntegrityCheck = new System.Byte[] { 0 };
aValue.IntegrityCheckAlgorithm = new System.Nullable<MARC.Everest.DataTypes.Interfaces.EncapsulatedDataIntegrityAlgorithm>(MARC.Everest.DataTypes.Interfaces.EncapsulatedDataIntegrityAlgorithm.SHA1);
aValue.Thumbnail = new MARC.Everest.DataTypes.ED(new System.Byte[] { 0 }, "0");
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.ED>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.ED)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void IIEqualsSerializationTest()
{
MARC.Everest.DataTypes.II aValue = new MARC.Everest.DataTypes.II(), bValue = null;
aValue.Root = "0";
aValue.Extension = "0";
aValue.Displayable = false;
aValue.Use = new System.Nullable<MARC.Everest.DataTypes.IdentifierUse>(MARC.Everest.DataTypes.IdentifierUse.Business);
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.II>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.II)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void SXPRTSMixedComponentsFormatting()
{
SXPR<TS> test = SXPR<TS>.CreateSXPR(new IVL<TS>(DateTime.Now, DateTime.Now.AddDays(1)),
new PIVL<TS>(
new IVL<TS>(DateTime.Now, DateTime.Now.AddDays(1)),
new PQ((decimal)1.0, "y")
),
//new SXCM<TS>(DateTime.Now) { Operator = SetOperator.A },
new IVL<TS>(DateTime.Now) { Operator = SetOperator.Intersect },
new EIVL<TS>(DomainTimingEventType.BeforeLunch,
new IVL<PQ>(
new PQ((decimal)1.0, "d")
)
) { Operator = SetOperator.Inclusive });
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter();
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw));
xw.WriteStartElement("sxpr");
fmtr.Graph(xw, test);
xw.WriteEndElement(); // comp
xw.Flush();
Tracer.Trace(sw.ToString());
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
var parse = fmtr.Parse(rdr, typeof(SXPR<TS>)).Structure as SXPR<TS>;
Assert.AreEqual(parse.Count, test.Count);
for (int i = 0; i < parse.Count; i++)
Assert.AreEqual(parse[i].GetType(), test[i].GetType());
}
public void SXPRSTMixedComponentsFormatting()
{
SXPR<RTO<INT, INT>> test = SXPR<RTO<INT, INT>>.CreateSXPR(new IVL<RTO<INT,INT>>(new RTO<INT,INT>(1,3), new RTO<INT,INT>(2,3)),
new PIVL<RTO<INT,INT>>(
new IVL<RTO<INT,INT>>(new RTO<INT,INT>(2,3),new RTO<INT,INT>(5,6)),
new PQ((decimal)1.0, "y")
)
//new SXCM<RTO<INT,INT>>(new RTO<INT,INT>(1,2)) { Operator = SetOperator.A },
//new IVL<RTO<INT,INT>>(new RTO<INT,INT>(1,2)) { Operator = SetOperator.Intersect
);
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter();
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw));
xw.WriteStartElement("sxpr");
fmtr.Graph(xw, test);
xw.WriteEndElement(); // comp
xw.Flush();
Tracer.Trace(sw.ToString());
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
var parse = fmtr.Parse(rdr, typeof(SXPR<RTO<INT, INT>>)).Structure as SXPR<RTO<INT, INT>>;
Assert.AreEqual(parse.Count, test.Count);
for (int i = 0; i < parse.Count; i++)
Assert.AreEqual(parse[i].GetType(), test[i].GetType());
}
public void EV_1110_DefaultUniprocessorCustomTypeTest()
{
// Load a sample because I don't want to write a full construction method
ClinicalDocument clinicalDocument = null;
using (Stream inStream = typeof(EV_1110).Assembly.GetManifestResourceStream("MARC.Everest.Test.Resources.phrDocTesting_140219112155-0500.xml"))
{
XmlIts1Formatter fmtr = new XmlIts1Formatter();
fmtr.ValidateConformance = false;
fmtr.GraphAides.Add(new ClinicalDocumentDatatypeFormatter());
var result = fmtr.Parse(XmlReader.Create(inStream), typeof(ClinicalDocument));
clinicalDocument = result.Structure as ClinicalDocument;
}
var observation = new ObservationMyProfile()
{
MoodCode = x_ActMoodDocumentObservation.Eventoccurrence,
Code = "3202-20",
EntryRelationship = new List<EntryRelationship>()
{
new EntryRelationship(x_ActRelationshipEntryRelationship.HasComponent, true)
{
ClinicalStatement = new ObservationMyProfile()
}
}
}
;
CascadeNullFlavor(observation.EntryRelationship[0], NullFlavor.Unknown);
// Cascade a null flavor on one of the entries
clinicalDocument.Component.GetBodyChoiceIfStructuredBody().Component[1].Section.Entry.Add(new Entry(
x_ActRelationshipEntry.HasComponent,
false,
observation
));
// Cascade a null flavor on one of the entries
clinicalDocument.Component.GetBodyChoiceIfStructuredBody().Component[2].Section.Entry.Add(new Entry(
x_ActRelationshipEntry.HasComponent,
false,
observation
));
// Cascade a null flavor on one of the entries
clinicalDocument.Component.GetBodyChoiceIfStructuredBody().Component[3].Section.Entry.Add(new Entry(
x_ActRelationshipEntry.HasComponent,
false,
observation
));
StringWriter sw = new StringWriter();
using (XmlWriter xw = XmlWriter.Create(sw, new XmlWriterSettings() { Indent = true }))
{
XmlIts1Formatter fmtr = new XmlIts1Formatter();
fmtr.ValidateConformance = false;
fmtr.GraphAides.Add(new ClinicalDocumentDatatypeFormatter());
fmtr.Settings = SettingsType.DefaultUniprocessor;
fmtr.Settings |= SettingsType.SuppressXsiNil;
fmtr.Settings |= SettingsType.SuppressNullEnforcement;
fmtr.Settings |= SettingsType.AlwaysCheckForOverrides;
fmtr.RegisterXSITypeName("POCD_MT000040.Observation", typeof(MARC.Everest.Test.Regressions.EV_1102.ObservationWithConfidentialityCode));
using (XmlStateWriter xsw = new XmlStateWriter(xw))
{
xsw.WriteStartElement("hl7", "ClinicalDocument", "urn:hl7-org:v3");
xsw.WriteAttributeString("xmlns", "xsi", null, XmlIts1Formatter.NS_XSI);
xsw.WriteAttributeString("schemaLocation", XmlIts1Formatter.NS_XSI, @"urn:hl7-org:v3 Schemas/CDA-PITO-E2E.xsd");
xsw.WriteAttributeString("xmlns", null, null, @"urn:hl7-org:v3");
xsw.WriteAttributeString("xmlns", "hl7", null, @"urn:hl7-org:v3");
xsw.WriteAttributeString("xmlns", "e2e", null, @"http://standards.pito.bc.ca/E2E-DTC/cda");
xsw.WriteAttributeString("xmlns", "xs", null, @"http://www.w3.org/2001/XMLSchema");
IFormatterGraphResult result = fmtr.Graph(xsw, clinicalDocument);
foreach (ResultDetail itm in result.Details)
Trace.WriteLine(String.Format("{0}:{1} @ {2}", itm.Type, itm.Message, itm.Location));
xsw.WriteEndElement(); // clinical document
xsw.Flush();
}
}
Trace.WriteLine(sw.ToString());
Regex re = new Regex(@"\<entryRelationship.*/\>");
if (re.IsMatch(sw.ToString()))
Assert.Fail("Output of entry relationship is not as expected");
}
public void ADEqualsSerializationTest()
{
MARC.Everest.DataTypes.AD aValue = new MARC.Everest.DataTypes.AD(), bValue = null;
aValue.Use = new MARC.Everest.DataTypes.SET<MARC.Everest.DataTypes.CS<MARC.Everest.DataTypes.PostalAddressUse>>(0) { new MARC.Everest.DataTypes.CS<MARC.Everest.DataTypes.PostalAddressUse>(MARC.Everest.DataTypes.PostalAddressUse.HomeAddress) };
aValue.IsNotOrdered = false;
aValue.Part.Add(new MARC.Everest.DataTypes.ADXP("123 Main Street West", MARC.Everest.DataTypes.AddressPartType.AddressLine));
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test", "urn:hl7-org:v3");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.AD>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.AD)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void IVLEqualsSerializationLowTest()
{
MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.INT> aValue = new MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.INT>(), bValue = null;
aValue.Low = new MARC.Everest.DataTypes.INT(0);
aValue.LowClosed = false;
//aValue.High = new MARC.Everest.DataTypes.INT(0);
//aValue.HighIncluded = false;
//aValue.Width = new MARC.Everest.DataTypes.PQ(0, "0");
aValue.Operator = new System.Nullable<MARC.Everest.DataTypes.SetOperator>(MARC.Everest.DataTypes.SetOperator.Hull);
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.INT>>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.INT>)).Structure);
Assert.AreEqual(aValue, bValue);
}
public void PIVLEqualsSerializationTest()
{
MARC.Everest.DataTypes.PIVL<MARC.Everest.DataTypes.INT> aValue = new MARC.Everest.DataTypes.PIVL<MARC.Everest.DataTypes.INT>(), bValue = null;
aValue.Phase = new MARC.Everest.DataTypes.IVL<MARC.Everest.DataTypes.INT>(new MARC.Everest.DataTypes.INT(0));
aValue.Period = new MARC.Everest.DataTypes.PQ((decimal)0, "0");
aValue.Alignment = new System.Nullable<MARC.Everest.DataTypes.CalendarCycle>(MARC.Everest.DataTypes.CalendarCycle.Year);
aValue.InstitutionSpecified = false;
aValue.Operator = new System.Nullable<MARC.Everest.DataTypes.SetOperator>(MARC.Everest.DataTypes.SetOperator.Hull);
aValue.Flavor = "0";
StringWriter sw = new StringWriter();
DatatypeFormatter fmtr = new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian };
XmlStateWriter xw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings() { Encoding = System.Text.Encoding.UTF8 }));
xw.WriteStartElement("test");
fmtr.Graph(xw, aValue);
xw.WriteEndElement(); // comp
xw.Flush();
StringReader sr = new StringReader(sw.ToString());
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
rdr.Read(); rdr.Read();
bValue = Util.Convert<MARC.Everest.DataTypes.PIVL<MARC.Everest.DataTypes.INT>>(fmtr.Parse(rdr, typeof(MARC.Everest.DataTypes.PIVL<MARC.Everest.DataTypes.INT>)).Structure);
Assert.AreEqual(aValue, bValue);
}
/// <summary>
/// Graphs object <paramref name="o"/> onto stream <paramref name="s"/>
/// </summary>
/// <param name="s">The stream to which <paramref name="o"/> is to be graphed</param>
/// <param name="o">The object to be graphed</param>
/// <returns>A <see cref="T:MARC.Everest.Formatters.XML.ITS1.Its1FormatterGraphResult"/> structure contianing the
/// results of formatting</returns>
/// <seealso cref="F:Graph(System.Xml.XmlWriter,MARC.Everest.Interfaces.IGraphable)"/>
public IFormatterGraphResult Graph(Stream s, IGraphable o)
{
ThrowIfDisposed();
XmlWriter xwtr = XmlWriter.Create(s);
XmlStateWriter xw = new XmlStateWriter(xwtr);
if (o == null)
return new XmlIts1FormatterGraphResult(ResultCode.AcceptedNonConformant, null);
//TODO: Length will never be less than 0 so the logic should be > 0 instead of != 0.
bool needsRoot = o.GetType().GetCustomAttributes(typeof(InteractionAttribute), true).Length == 0;
if (needsRoot)
{
object[] sa = o.GetType().GetCustomAttributes(typeof(StructureAttribute), true);
needsRoot = sa.Length == 0 || !(sa[0] as StructureAttribute).IsEntryPoint;
if (needsRoot)
{
xw.WriteStartElement(o.GetType().FullName, "urn:hl7-org:v3");
xw.WriteAttributeString("xmlns", "xsi", null, XmlIts1Formatter.NS_XSI);
}
}
// Determine if this is not an interaction
var result = Graph(xw, o);
if (needsRoot)
xw.WriteEndElement();
xw.Flush();
return result;
}