/// <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);
}
}
