/// <summary> /// Builds a <see cref="IDataQuery"/> list from a message that contains one or more data queries /// </summary> /// <param name="dataQueryLocation"> /// The data location /// </param> /// <param name="beanRetrievalManager"> /// optional, if given will retrieve the key family bean the query is for /// </param> /// <returns> /// a <see cref="IDataQuery"/> list /// </returns> public IList<IDataQuery> BuildDataQuery( IReadableDataLocation dataQueryLocation, ISdmxObjectRetrievalManager beanRetrievalManager) { this._log.Debug("DataParseManagerImpl.buildDataQuery"); using (ISdmxXmlStream xmlStream = new SdmxXmlStream(dataQueryLocation)) { LoggingUtil.Debug(this._log, "Schema Version Determined to be : " + xmlStream.SdmxVersion); return this.BuildDataQuery(xmlStream, beanRetrievalManager); } }
public void TestXmlReaderCtor(string file) { using (var doc = XmlReader.Create(file)) using (var readable = new SdmxXmlStream(doc, MessageEnumType.Structure, SdmxSchemaEnumType.VersionTwo, RegistryMessageEnumType.Null)) { Assert.IsTrue(readable.HasReader); Assert.IsNotNull(readable.Reader); Assert.AreEqual(MessageEnumType.Structure, readable.MessageType); Assert.AreEqual(SdmxSchemaEnumType.VersionTwo, readable.SdmxVersion); Assert.AreEqual(RegistryMessageEnumType.Null, readable.RegistryType); } }
public void TestReadableDataLocationCtor(string file) { using (var readable = new FileReadableDataLocation(file)) { using (var sdmxXmlStream = new SdmxXmlStream(readable)) { Assert.IsTrue(sdmxXmlStream.HasReader); Assert.IsNotNull(sdmxXmlStream.Reader); Assert.AreEqual(MessageEnumType.Structure, sdmxXmlStream.MessageType); Assert.AreEqual(SdmxSchemaEnumType.VersionTwo, sdmxXmlStream.SdmxVersion); Assert.AreEqual(RegistryMessageEnumType.Null, sdmxXmlStream.RegistryType); } } }
/// <summary> /// The main. /// </summary> /// <param name="args"> /// The args. /// </param> /// <exception cref="InvalidOperationException"> /// Could not load Structure objects /// </exception> public static void Main(string[] args) { // 1. Initialize the StructureMutableParsingManager. This implementation supports only 2.0. It also supports the SdmxXmlStream IStructureParsingManager parsingManager = new StructureMutableParsingManager(); // 2. Create a SdmxXmlStream. It provides a non-buffered, forward only access to an existing XmlReader or XmlWriter. using (var stream = File.OpenRead("ESTAT_CPI_v1.0.xml")) using (var reader = XMLParser.CreateSdmxMlReader(stream, SdmxSchemaEnumType.VersionTwo)) using (var dataLocation = new SdmxXmlStream(reader, MessageEnumType.Structure, SdmxSchemaEnumType.VersionTwo, RegistryMessageEnumType.Null)) { // 3. Get the IStructureWorkspace IStructureWorkspace structureWorkspace = parsingManager.ParseStructures(dataLocation); // 4. Get the ISdmxObjects with resolving cross-references. ISdmxObjects structureObjects = structureWorkspace.GetStructureObjects(false); if (structureObjects == null) { throw new InvalidOperationException("Could not load Structure objects"); } } }
public void TestWritableCtor2() { using (var doc = new WriteableDataLocationTmp()) { using (var b = new SdmxXmlStream(doc, true)) using (var readable = new SdmxXmlStream(b, true)) { Assert.IsTrue(readable.HasWriter); Assert.IsNotNull(readable.Writer); } } }
public void TestOutStreamCtor() { using (var doc = new FileStream("TestXmlWriterCtor.xml", FileMode.Create)) using (var readable = new SdmxXmlStream(doc, true)) { Assert.IsTrue(readable.HasWriter); Assert.IsNotNull(readable.Writer); } }
public void TestXmlWriterCtor() { using (var doc = XmlWriter.Create("TestXmlWriterCtor.xml")) using (var readable = new SdmxXmlStream(doc)) { Assert.IsTrue(readable.HasWriter); Assert.IsNotNull(readable.Writer); } }
/// <summary> /// Processes the SDMX at the given URI and returns a workspace containing the information on what was being queried. /// <p/> /// The Query parsing manager processes queries that are in a RegistryInterface document, this includes queries for /// Provisions, Registrations and Structures. It also processes Queries that are in a QueryMessage document /// </summary> /// <param name="dataLocation"> /// The data location of the query /// </param> /// <returns> /// The <see cref="IQueryWorkspace"/> from <paramref name="dataLocation"/>. /// </returns> public virtual IQueryWorkspace ParseQueries(IReadableDataLocation dataLocation) { LoggingUtil.Debug(_log, "Parse Structure request, for xml at location: " + dataLocation); using (ISdmxXmlStream xmlStream = new SdmxXmlStream(dataLocation)) { return this.ParseQueries(xmlStream); } }
/// <summary> /// Parses a structure document OR a Registry document that contains structures. /// </summary> /// <param name="dataLocation"> /// The structure location /// </param> /// <param name="settings"> /// - addition settings to perform when parsing /// </param> /// <param name="retrievalManager"> /// The retrieval manager. /// </param> /// <returns> /// StructureWorkspace - from this structures can be retrieved in any format required /// </returns> /// <remarks> /// Validates the SDMX-ML against the correct schema, also validates the structure according to the SDMX standards, /// using rules which can not be specified by schema. Uses the supplied settings to perform any extra operations. If /// resolve external references is set to true, then these structures will also be validated against the Schema and business logic. /// </remarks> public IStructureWorkspace ParseStructures(IReadableDataLocation dataLocation, ResolutionSettings settings, ISdmxObjectRetrievalManager retrievalManager) { var xmlStream = dataLocation as ISdmxXmlStream; if (xmlStream != null) { return this.ParseStructures(xmlStream, settings, retrievalManager); } _log.DebugFormat("Parse Structure request, for xml at location: {0} ", dataLocation); MessageEnumType structureType = SdmxMessageUtil.GetMessageType(dataLocation); XmlReaderSettings xmlSettings = XMLParser.GetSdmxXmlReaderSettings(SdmxSchemaEnumType.VersionTwo); xmlSettings.ValidationEventHandler += OnValidationEventHandler; xmlSettings.NameTable = NameTableCache.Instance.NameTable; using (Stream inputStream = dataLocation.InputStream) using (XmlReader reader = XmlReader.Create(inputStream, xmlSettings)) { xmlStream = new SdmxXmlStream(reader, structureType, SdmxSchemaEnumType.VersionTwo, RegistryMessageEnumType.QueryStructureResponse); return this.ParseStructures(xmlStream, settings, retrievalManager); } }