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 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 EV_1089SampleReflectParseTest() { try { var instance = ParseFromStreamTest.FindResource("REPC_IN002120UV01.xml"); // Parse XmlIts1Formatter fmtr = new XmlIts1Formatter() { GraphAides = new List<Connectors.IStructureFormatter>() { new DatatypeFormatter() }, Settings = SettingsType.DefaultUniprocessor }; XmlStateReader reader = new XmlStateReader(XmlReader.Create(ParseFromStreamTest.GetResourceStream(instance))); var result = fmtr.Parse(reader, typeof(PRPA_IN201301UV02).Assembly); Assert.IsNotNull(((((result.Structure as REPC_IN002120UV01).controlActProcess.Subject[0].act.PertinentInformation3[3].CareStatement as RMIM.UV.NE2010.REPC_MT000100UV01.Observation).TargetOf[1].CareEntry as MARC.Everest.RMIM.UV.NE2010.REPC_MT000100UV01.SubstanceAdministration).Consumable.ConsumableChoice as RMIM.UV.NE2010.COCT_MT230100UV.Medication).AdministerableMedicine.Name); } catch { } }
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 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); }
/// <summary> /// Parse an object from <see cref="T:System.Xml.XmlReader"/> <paramref name="r"/> using the type /// hint <param name="t"/> /// </summary> /// <param name="r">The <see cref="T:System.Xml.XmlReader"/> to parse an object from</param> /// <param name="t">The type hint to parse the object</param> /// <returns>A <see cref="T:MARC.Everest.Formatters.XML.ITS1.Its1FormatterParseResult"/> containing the formatted instance</returns> /// <remarks> /// <para> /// This particular overload of the Graph method can be used to graph objects into a <see cref="T:System.Xml.XmlWriter"/> and can provide /// an opportunity to use Everest as an assistant (or XmlSerializerSurrogate) for more complex systems like WCF. /// </para> /// <example> /// <code lang="cs" title="Using Everest as a Serializer Assistant"> /// <![CDATA[ /// StringWriter sw = new StringWriter("<hello><MCCI_IN000002CA xmlns=\"urn:hl7-org:v3\"/></hello>"); /// XmlReader reader = XmlReader.Create(sw); /// reader.Read(); // Read <hello> /// /// Formatter f = new Formatter(); /// f.GraphAides.Add(typeof(MARC.Everest.Formatters.XML.DataTypes.R1.Formatter)); /// f.ValidateConformance = false; /// var result = f.Parse(reader, typeof(MCCI_IN000002CA)); /// /// reader.Read(); /// reader.Close(); /// Console.WriteLine(result.Code); /// /// ]]> /// </code> /// </example> /// <para> /// When using this method, it is recommended that you pass a <see cref="T:MARC.Everest.Xml.XmlStateReader"/> as it /// will allow the formatter to give additional location information when reporting issues. /// </para> /// </remarks> public IFormatterParseResult Parse(XmlReader r, Type t) { if (!(r is XmlStateReader)) r = new XmlStateReader(r); // Initial state if (r.ReadState == ReadState.Initial) while (r.NodeType != XmlNodeType.Element) r.Read(); // Detect if we can parse this... if (r.NamespaceURI != "urn:hl7-org:v3") throw new XmlException(string.Format("Can't parse '{0}' in namespace '{1}'. The data does not appear to be an HL7v3 instance", r.LocalName, r.NamespaceURI), null); var resultContext = new XmlIts1FormatterParseResult(ResultCode.Accepted, null); resultContext.Structure = ParseObject(r, t, null, resultContext); return resultContext; }
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 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 EV_1089SETParseTest() { PRPA_IN201305UV02 test = new PRPA_IN201305UV02(); test.Sender = new RMIM.UV.NE2010.MCCI_MT100200UV01.Sender(); test.Sender.Device = new RMIM.UV.NE2010.MCCI_MT100200UV01.Device(); test.Sender.Device.Id = new SET<II>() { NullFlavor = NullFlavor.NoInformation }; XmlIts1Formatter fmtr = new XmlIts1Formatter(); fmtr.GraphAides.Add(new DatatypeFormatter()); var sw = new StringWriter(); XmlStateWriter writer = new XmlStateWriter(XmlWriter.Create(sw)); fmtr.Graph(writer, test); writer.Flush(); String xmlString = sw.ToString(); StringReader sr = new StringReader(xmlString); XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr)); var result = fmtr.Parse(rdr); Assert.IsNotNull(result.Structure as PRPA_IN201305UV02); Assert.IsNotNull((result.Structure as PRPA_IN201305UV02).Sender.Device.Id); //Assert.AreEqual(test, result.Structure); }
public void IVLInclusiveParsingTest() { StringReader sr = new StringReader("<ivl xmlns=\"urn:hl7-org:v3\"><low inclusive=\"true\" value=\"1\" /><high inclusive=\"false\" value=\"4\" /></ivl>"); XmlStateReader rdr = new XmlStateReader(XmlReader.Create(sr)); // Read to first node while(rdr.NodeType != XmlNodeType.Element) rdr.Read(); // Parse MARC.Everest.Formatters.XML.Datatypes.R1.DatatypeFormatter fmtr = new MARC.Everest.Formatters.XML.Datatypes.R1.DatatypeFormatter(); IVL<INT> retVal = fmtr.Parse(rdr, typeof(IVL<INT>)).Structure as IVL<INT>; Assert.IsTrue(retVal.HighClosed.HasValue); Assert.IsTrue(retVal.LowClosed.HasValue); Assert.IsFalse(retVal.HighClosed.Value); Assert.IsTrue(retVal.LowClosed.Value); }
public void WI1086_VerifyBugReflectTest() { // Load the XmlInstance into a string reader StringReader sr = new StringReader(this.m_xmlInstance); XmlStateReader xr = new XmlStateReader(XmlReader.Create(sr)); XmlIts1Formatter formatter = new XmlIts1Formatter(); formatter.ValidateConformance = false; formatter.Settings = SettingsType.DefaultUniprocessor; formatter.GraphAides.Add(new DatatypeFormatter() { CompatibilityMode = DatatypeFormatterCompatibilityMode.Canadian }); try { MCCI_IN000002CA instance = formatter.Parse(xr, typeof(MCCI_IN000002CA)).Structure as MCCI_IN000002CA; if (instance == null) throw new InvalidOperationException("Invalid test data"); // Test 1, /receiver should be null (xsi:nil = true) Assert.IsNull(instance.Receiver, "Receiver"); // Test 2, /sender should also be null (xsi:nil = true) Assert.IsNull(instance.Sender, "Sender"); // Test 3, /acknowledgement should not be null and should have a null flavor (a notification should be notified though) Assert.IsNotNull(instance.Acknowledgement); Assert.AreEqual((NullFlavor)instance.Acknowledgement.NullFlavor.Code, NullFlavor.Unavailable); } finally { formatter.Dispose(); } }
/// <summary> /// Parses an object from <paramref name="r"/> using <paramref name="a"/> to locate /// a suitable class definition to populate. /// </summary> /// <param name="r">The <see cref="T:System.Xml.XmlReader"/> from which to parse the object</param> /// <param name="a"><paramref name="s"/> in object form</param> /// <returns>A <see cref="MARC.Everest.Formatters.XML.ITS1.Its1FormatterParseResult"/> containing the results of the parse</returns> /// <remarks> /// <para>This method differs from the <seealso cref="F:Parse(System.Xml.XmlReader)"/> method in that it /// will only look within the specified assembly for a suitable class to populate.</para> /// <para> /// This method will not check the current learned type repository for a class to serialize (ie: it will always /// check the assembly regardless of what has been formatted prior) /// </para> /// </remarks> public IFormatterParseResult Parse(XmlReader r, Assembly a) { ThrowIfDisposed(); var resultContext = new XmlIts1FormatterParseResult(ResultCode.Accepted, null); if (!(r is XmlStateReader)) r = new XmlStateReader(r); // Initial state if (r.ReadState == ReadState.Initial) while (r.NodeType != XmlNodeType.Element) r.Read(); // Detect if we can parse this... //if (r.NamespaceURI != "urn:hl7-org:v3") // throw new XmlException(string.Format("Can't parse '{0}' in namespace '{1}'. The data does not appear to be an HL7v3 instance", r.LocalName, r.NamespaceURI), null); // Predicate will find the mapped type for us Predicate<Type> typeComparator = delegate(Type t) { object[] structureAttribute = t.GetCustomAttributes(typeof(StructureAttribute), true); if (structureAttribute.Length > 0 && ((structureAttribute[0] as StructureAttribute).StructureType == StructureAttribute.StructureAttributeType.Interaction || (structureAttribute[0] as StructureAttribute).IsEntryPoint) && (structureAttribute[0] as StructureAttribute).Name == r.LocalName && (structureAttribute[0] as StructureAttribute).NamespaceUri == r.NamespaceURI) return true; return false; }; // Try to find the value if it doesn't succeed, try to build it and try to find it again #if WINDOWS_PHONE Type fType = a.GetTypes().Find(typeComparator); #else Type fType = Array.Find<Type>(a.GetTypes(), typeComparator); #endif // Found the type if (fType != null) resultContext.Structure = this.ParseObject(r, fType, fType, resultContext); else resultContext.AddResultDetail( new ResultDetail(ResultDetailType.Error, String.Format("Could not find a type to de-serialize '{0}' into", r.Name), r.ToString(), null) ); // Set the acceptance code resultContext.Code = CalculateResultCode(resultContext.Details); return resultContext; }
/// <summary> /// Parse an object from <paramref name="s"/> /// </summary> /// <param name="s">The stream from which to parse an object</param> /// <returns>An <see cref="T:MARC.Everest.Formatters.XML.ITS1.Its1FormatterParseResult"/> structure containing the parsed information</returns> /// <remarks> /// <para> /// The parse method will attempt to search any of the already known types (ie: types already learned) for a serialization start point. If /// one is not found, the method will search the current AppDomain to find <see cref="T:MARC.Everest.Interfaces.IGraphable"/> classes /// which can be used to interpret the data within the stream. For this, the root element is used to find /// which of the types can start serialization. /// </para> /// <para> /// While this method will work fine when dealing with one RMIM assembly, it is recommended that you use the /// <seealso cref="F:Graph(System.IO.Stream,System.Reflection.Assembly)"/> method when more than one RMIM assembly /// is loaded in memory. /// </para> /// </remarks> public IFormatterParseResult Parse(Stream s) { XmlReader rdr = new XmlStateReader(XmlReader.Create(s)); try { return Parse(rdr); // Parse the object using the XML Reader } finally { rdr.Close(); } }
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 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); }
/// <summary> /// Validate the MIF file /// </summary> public void ValidateMifFile(Stream fileStream, string fileName) { string mifDirectory = Path.Combine(Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), "schemas"), "mif2.1.4"); // First, validate the schema directory exists if (context.Mode != Pipeline.OperationModeType.Strict) { Trace.Write("Not operating in strict mode, not applying MIF validation", "warn1"); return; } if (!Directory.Exists(mifDirectory)) throw new InvalidOperationException("Cannot find the MIF schemas, ensure that the Schemas\\mif2.1.4 directory exists"); // Load the schemas if (m_schemas == null) { m_schemas = new XmlSchemaSet(); m_schemas.ValidationEventHandler += new ValidationEventHandler(m_schemas_ValidationEventHandler); foreach (var file in Directory.GetFiles(mifDirectory, "*.xsd")) { XmlReader schemaReader = XmlReader.Create(file, new XmlReaderSettings() { ProhibitDtd = false }); try { m_schemas.Add("urn:hl7-org:v3/mif2", schemaReader); } finally { schemaReader.Close(); } } m_schemas.Compile(); } // Sanity check if (!m_schemas.IsCompiled) throw new InvalidOperationException("The schema set must compile successfully for execution to continue"); // Reader XmlStateReader xr = null; try { // Create settings var settings = new XmlReaderSettings() { ProhibitDtd = false, ValidationType = ValidationType.Schema, Schemas = m_schemas }; // Is the object valid bool isValid = true; settings.ValidationEventHandler += new ValidationEventHandler( delegate(object sender, ValidationEventArgs e) { Trace.WriteLine(String.Format("{0} : {1}", Path.GetFileName(fileName), e.Message), e.Severity == XmlSeverityType.Error ? "error" : "warn"); isValid &= e.Severity == XmlSeverityType.Warning; } ); // Create the reader xr = new XmlStateReader(XmlReader.Create(fileStream, settings)); // Read while (xr.Read()) ; if (!isValid) throw new XmlSchemaValidationException("File failed basic schema check"); } finally { if (xr != null) xr.Close(); } }
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 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 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 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 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> /// Parse an object from <see cref="T:System.Xml.XmlReader"/> <paramref name="r"/> /// </summary> /// <param name="r">The <see cref="T:System.Xml.XmlReader"/> to parse an object from</param> /// <returns>A <see cref="T:MARC.Everest.Formatters.XML.ITS1.Its1FormatterParseResult"/> containing the formatted instance</returns> /// <remarks> /// <para> /// This particular overload of the Graph method can be used to graph objects into a <see cref="T:System.Xml.XmlWriter"/> and can provide /// an opportunity to use Everest as an assistant (or XmlSerializerSurrogate) for more complex systems like WCF. /// </para> /// <example> /// <code lang="cs" title="Using Everest as a Serializer Assistant"> /// <![CDATA[ /// StringWriter sw = new StringWriter("<hello><MCCI_IN000002CA xmlns=\"urn:hl7-org:v3\"/></hello>"); /// XmlReader reader = XmlReader.Create(sw); /// reader.Read(); // Read <hello> /// /// Formatter f = new Formatter(); /// f.GraphAides.Add(typeof(MARC.Everest.Formatters.XML.DataTypes.R1.Formatter)); /// f.ValidateConformance = false; /// var result = f.Parse(reader); /// /// reader.Read(); /// reader.Close(); /// Console.WriteLine(result.Code); /// /// ]]> /// </code> /// </example> /// <para> /// When using this method, it is recommended that you pass a <see cref="T:MARC.Everest.Xml.XmlStateReader"/> as it /// will allow the formatter to give additional location information when reporting issues. /// </para> /// </remarks> public IFormatterParseResult Parse(XmlReader r) { ThrowIfDisposed(); // Clear existing results XmlIts1FormatterParseResult resultContext = new XmlIts1FormatterParseResult(ResultCode.Accepted, null); if (!(r is XmlStateReader)) r = new XmlStateReader(r); // Initial state if (r.ReadState == ReadState.Initial) while (r.NodeType != XmlNodeType.Element) r.Read(); // Detect if we can parse this... //if (r.NamespaceURI != "urn:hl7-org:v3") // throw new XmlException(string.Format("Can't parse '{0}' in namespace '{1}'. The data does not appear to be an HL7v3 instance", r.LocalName, r.NamespaceURI), null); // Do we have a formatter for the object Type mappedType; // Predicate will find the mapped type for us Predicate<Type> typeComparator = delegate(Type t) { object[] structureAttribute = t.GetCustomAttributes(typeof(StructureAttribute), true); if (structureAttribute.Length > 0 && ((structureAttribute[0] as StructureAttribute).StructureType == StructureAttribute.StructureAttributeType.Interaction || (structureAttribute[0] as StructureAttribute).IsEntryPoint) && (structureAttribute[0] as StructureAttribute).Name == r.LocalName && (structureAttribute[0] as StructureAttribute).NamespaceUri == r.NamespaceURI) return true; return false; }; // Try to find the value if it doesn't succeed, try to build it and try to find it again for (int i = 0; i < 2 && resultContext.Structure == null; i++) { if (s_rootNameMaps.TryGetValue(r.LocalName, out mappedType)) // Try to get a root name map { resultContext.Structure = ParseObject(r, mappedType, mappedType, resultContext); resultContext.Code = CalculateResultCode(resultContext.Details); return resultContext; } else if (i == 0) // Try to build the cache for this root name { // Last attempt, try to find a type in the app domain that we can scan! Predicate<Assembly> asmPredicate = delegate(Assembly a) { try { #if WINDOWS_PHONE return a.GetTypes().Exists(typeComparator); #else return Array.Find<Type>(a.GetTypes(), typeComparator) != null; #endif } catch { return false; } }; #if WINDOWS_PHONE Assembly asm = AppDomain.CurrentDomain.GetAssemblies().Find(asmPredicate); #else Assembly asm = Array.Find<Assembly>(AppDomain.CurrentDomain.GetAssemblies(), asmPredicate); #endif if (asm == null) // Couldn't find assembly... ditch break; else return Parse(r, asm); //BuildCache(new Type[] { Array.Find<Type>(asm.GetTypes(), typeComparator) }); } //i++; } resultContext.AddResultDetail(new ResultDetail(ResultDetailType.Error, String.Format("Could not find a type to de-serialize '{0}' into", r.Name), r.ToString(), null)); resultContext.Code = ResultCode.Rejected; return resultContext; }