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());
}
}
/// <summary>
/// Logs the message.
/// </summary>
/// <param name="message">The message to log.</param>
private static void LogMessage(IGraphable message)
{
XmlWriter writer = null;
var formatter = new XmlIts1Formatter
{
ValidateConformance = true,
};
var dtf = new DatatypeFormatter();
formatter.GraphAides.Add(dtf);
var sb = new StringBuilder();
writer = XmlWriter.Create(sb, new XmlWriterSettings {
Indent = true, OmitXmlDeclaration = true
});
var stateWriter = new XmlStateWriter(writer);
formatter.Graph(stateWriter, message);
stateWriter.Flush();
traceSource.TraceEvent(TraceEventType.Verbose, 0, sb.ToString());
}
/// <summary>
/// Format a data type into a string in a localisation namespace
/// </summary>
/// <param name="dataType">The data type to format</param>
/// <param name="elementName">The name of the element</param>
public static void SerialiseDataType(IGraphable dataType, XmlWriter xmlWriter, string elementName, string localNamespace)
{
if (dataType != null)
{
xmlWriter.WriteStartElement(elementName, localNamespace);
DatatypeFormatter ft = new DatatypeFormatter(DatatypeFormatterCompatibilityMode.ClinicalDocumentArchitecture);
ft.GraphObject(xmlWriter, dataType);
xmlWriter.WriteEndElement();
}
}
/// <summary>
/// Parse a string
/// </summary>
/// <param name="actualXml"></param>
/// <param name="type"></param>
/// <returns></returns>
internal static object ParseString(string xmlString, Type type)
{
StringReader sr = new StringReader(xmlString);
DatatypeFormatter fmtr = new DatatypeFormatter();
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
while (rdr.NodeType != XmlNodeType.Element)
{
rdr.Read();
}
var result = fmtr.Parse(rdr, type);
Assert.AreEqual(ResultCode.Accepted, result.Code);
return(result.Structure);
}
public void GetSupportedPropertiesTest01()
{
// Create the data type formatter
IDatatypeStructureFormatter datatypeFormatter = new DatatypeFormatter();
// Get supported properties for ED
var supportedProperties =
datatypeFormatter.GetSupportedProperties(typeof(ED));
// Determine if Translation is supported
bool isTranslationSupported =
Array.Exists(supportedProperties, o => o.Name == "Translation");
Console.WriteLine("ED.Translation is supported? {0}", isTranslationSupported);
Assert.AreNotEqual(true, isTranslationSupported);
}
/// <summary>
/// Graph the SXCM to the console
/// </summary>
public void Graph(System.Xml.XmlWriter s, object o, DatatypeFormatterGraphResult result)
{
// Output the object
Type t = o.GetType();
ANY any = (ANY)o;
object oper = t.GetProperty("Operator").GetValue(o, null),
valu = t.GetProperty("Value").GetValue(o, null);
if (oper != null && any.NullFlavor == null)
{
s.WriteAttributeString("operator", Util.ToWireFormat(oper));
}
// Format the object
var formatter = DatatypeFormatter.GetFormatter(valu.GetType());
formatter.Host = this.Host;
formatter.Graph(s, valu, result);
}
public void GetSupportedPropertiesTest04()
{
// Create the data type formatter
IDatatypeStructureFormatter datatypeFormatter = new DatatypeFormatter();
// Get supported properties for ED
var supportedProperties =
datatypeFormatter.GetSupportedProperties(typeof(ED));
// Determine if Compression is supported
bool isCompressionSupported =
Array.Exists(supportedProperties, o => o.Name == "Compression");
Console.WriteLine("ED.Compression is supported? {0}", isCompressionSupported);
// Same logic as test 3; rephrased for confirmation.
Assert.AreNotEqual(false, isCompressionSupported);
}
/// <summary>
/// Parse an SXCM from the wire
/// </summary>
public object Parse(System.Xml.XmlReader s, DatatypeFormatterParseResult result)
{
// Determine the generic type formatter
var formatter = DatatypeFormatter.GetFormatter(GenericArguments[0]);
// Create the return value
Type sxcmType = typeof(SXCM <>);
Type genType = sxcmType.MakeGenericType(GenericArguments);
ConstructorInfo ci = genType.GetConstructor(Type.EmptyTypes);
Object retVal = null;
if (ci != null)
{
retVal = ci.Invoke(null);
}
else
{
throw new ArgumentException("Constructor on type must have a parameterless constructor");
}
// Operator
if (s.GetAttribute("operator") != null)
{
genType.GetProperty("Operator").SetValue(retVal, Util.FromWireFormat(s.GetAttribute("operator"), typeof(SetOperator)), null);
}
// Value
if (formatter != null)
{
formatter.Host = this.Host;
var value = formatter.Parse(s, result);
genType.GetProperty("Value").SetValue(retVal, value, null);
if (value != null)
{
((ANY)retVal).NullFlavor = ((ANY)value).NullFlavor;
((ANY)retVal).Flavor = ((ANY)value).Flavor;
((ANY)value).NullFlavor = null;
((ANY)value).Flavor = null;
}
}
return(retVal);
}
/// <summary>
/// Serialize as a string
/// </summary>
internal static String SerializeAsString(IGraphable graph, DatatypeFormatterCompatibilityMode mode)
{
DatatypeFormatter fmtr = new DatatypeFormatter(mode);
StringWriter sw = new StringWriter();
XmlStateWriter xsw = new XmlStateWriter(XmlWriter.Create(sw, new XmlWriterSettings()
{
Indent = true
}));
xsw.WriteStartElement("test", "urn:hl7-org:v3");
xsw.WriteAttributeString("xmlns", "xsi", null, "http://www.w3.org/2001/XMLSchema-instance");
var result = fmtr.Graph(xsw, graph);
xsw.WriteEndElement();
xsw.Flush();
sw.Flush();
System.Diagnostics.Trace.WriteLine(sw.ToString());
Assert.AreEqual(ResultCode.Accepted, result.Code);
return(sw.ToString());
}
public void EV_1089ENXPParseTest()
{
EN myEn = EN.FromFamilyGiven(EntityNameUse.License, "Toet", "J");
myEn.Part[0].Qualifier = new SET <CS <EntityNamePartQualifier> >();
myEn.Part[1].Qualifier = new SET <CS <EntityNamePartQualifier> >();
myEn.Part[0].Qualifier.Add(EntityNamePartQualifier.Birth);
myEn.Part[1].Qualifier.Add(EntityNamePartQualifier.Initial);
String xmlString = R1SerializationHelper.SerializeAsString(myEn);
StringReader sr = new StringReader(xmlString);
DatatypeFormatter fmtr = new DatatypeFormatter();
XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr));
while (rdr.NodeType != XmlNodeType.Element)
{
rdr.Read();
}
var result = fmtr.Parse(rdr, typeof(EN));
Assert.AreEqual(0, result.Details.Count(o => o.Type == Connectors.ResultDetailType.Error));
}
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());
}
}
