/// <summary>
/// This is an internal method that is used to write the <paramref name="value"/> for the specified
/// <paramref name="locale"/>
/// The method create a XML element named by the name parameter.
/// It will only write the XML element if the text inside <paramref name="value"/> is not null or empty
/// </summary>
/// <param name="namespacePrefix">
/// The namespace prefix
/// </param>
/// <param name="name">
/// The name of the XML element
/// </param>
/// <param name="value">
/// The text value.
/// </param>
/// <param name="locale">
/// The locale.
/// </param>
protected void WriteTextType(
NamespacePrefixPair namespacePrefix, ElementNameTable name, string value, string locale)
{
if (!string.IsNullOrEmpty(value))
{
this._writer.WriteStartElement(
namespacePrefix.Prefix, NameTableCache.GetElementName(name), namespacePrefix.NS);
if (!string.IsNullOrEmpty(locale))
{
this._writer.WriteAttributeString(XmlConstants.XmlPrefix, XmlConstants.LangAttribute, null, locale);
}
this._writer.WriteString(value);
this._writer.WriteEndElement();
}
}
/// <summary>
/// Write the element if it's value is not empty or null
/// </summary>
/// <param name="namespacePrefix">
/// The namespace prefix pair
/// </param>
/// <param name="elementName">
/// The <see cref="ElementNameTable"/> element name
/// </param>
/// <param name="value">
/// The elements text
/// </param>
protected void TryToWriteElement(
NamespacePrefixPair namespacePrefix, ElementNameTable elementName, DateTime? value)
{
if (value.HasValue)
{
this.WriteElement(namespacePrefix, elementName, DateUtil.FormatDate(value.Value));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RegistryInterfaceWriterBaseV2"/> class.
/// </summary>
/// <exception cref="System.ArgumentNullException">
/// writer is null
/// </exception>
/// <param name="writer">
/// The XmlTextWriter object use to actually perform the writing
/// </param>
/// <param name="namespaces">
/// The namespaces.
/// </param>
protected RegistryInterfaceWriterBaseV2(XmlWriter writer, SdmxNamespaces namespaces)
: base(writer, namespaces)
{
this._commonPrefix = this.Namespaces.Common.Prefix;
this._defaultNs = this.Namespaces.Registry;
}
/// <summary>
/// Write an attribute with the specified name and value
/// </summary>
/// <param name="namespacePrefixPair">
/// The XML prefix
/// </param>
/// <param name="name">
/// Attribute name
/// </param>
/// <param name="value">
/// Attribute value
/// </param>
protected void WriteAttributeString(
NamespacePrefixPair namespacePrefixPair, AttributeNameTable name, string value)
{
this.WriteAttributeString(namespacePrefixPair, NameTableCache.GetAttributeName(name), value);
}
/// <summary>
/// Write an attribute with the specified name and value
/// </summary>
/// <param name="namespacePrefixPair">
/// The XML prefix
/// </param>
/// <param name="name">
/// Attribute name
/// </param>
/// <param name="value">
/// Attribute value
/// </param>
protected void WriteAttributeString(NamespacePrefixPair namespacePrefixPair, string name, string value)
{
this._writer.WriteAttributeString(namespacePrefixPair.Prefix, name, namespacePrefixPair.NS, value);
}
/// <summary>
/// Initializes a new instance of the <see cref="StructureWriterBaseV2"/> class.
/// Initializes a new instance of the <see cref="StructureWriterV2"/> class.
/// Constructor that initialize the internal fields
/// </summary>
/// <exception cref="System.ArgumentNullException">
/// writer is null
/// </exception>
/// <param name="writer">
/// The XmlWriter object use to actually perform the writing
/// </param>
/// <param name="namespaces">
/// The namespaces
/// </param>
protected StructureWriterBaseV2(XmlWriter writer, SdmxNamespaces namespaces)
: base(writer, _versionTwo, namespaces)
{
this._defaultNs = this.Namespaces.Structure;
this._rootNamespace = this.Namespaces.Message;
}
/// <summary>
/// Write a Start Element to the given XmlTextWriter using the given prefix and the <see cref="ElementNameTable"/> name
/// </summary>
/// <param name="ns">
/// The namespace and prefix
/// </param>
/// <param name="element">
/// The <see cref="ElementNameTable"/> element name
/// </param>
protected void WriteStartElement(NamespacePrefixPair ns, ElementNameTable element)
{
this.WriteStartElement(ns, NameTableCache.GetElementName(element));
}
/// <summary>
/// Write the element if it's value is not empty or null
/// </summary>
/// <param name="namespacePrefix">
/// The namespace prefix
/// </param>
/// <param name="element">
/// The <see cref="ElementNameTable"/> element name
/// </param>
/// <param name="value">
/// The elements text
/// </param>
protected void TryToWriteElement(NamespacePrefixPair namespacePrefix, ElementNameTable element, Uri value)
{
if (value != null)
{
this.WriteElement(namespacePrefix, element, value.ToString());
}
}
/// <summary>
/// Write the element
/// </summary>
/// <param name="namespacePrefix">
/// The namespace prefix
/// </param>
/// <param name="element">
/// The element name
/// </param>
/// <param name="value">
/// The elements text
/// </param>
protected void WriteElement(NamespacePrefixPair namespacePrefix, ElementNameTable element, string value)
{
this._writer.WriteElementString(
namespacePrefix.Prefix, NameTableCache.GetElementName(element), namespacePrefix.NS, value);
}
/// <summary>
/// Write the specified <paramref name="ns"/> declaration
/// </summary>
/// <param name="ns">
/// The namespace with prefix
/// </param>
protected void WriteNamespaceDecl(NamespacePrefixPair ns)
{
this.WriteAttributeString(XmlConstants.Xmlns, ns.Prefix, ns.NS);
}
/// <summary>
/// Write the element
/// </summary>
/// <param name="namespacePrefix">
/// The namespace prefix
/// </param>
/// <param name="element">
/// The element name
/// </param>
/// <param name="value">
/// The elements text
/// </param>
protected void WriteElement(NamespacePrefixPair namespacePrefix, string element, string value)
{
this._writer.WriteElementString(namespacePrefix.Prefix, element, namespacePrefix.NS, value);
}
/// <summary>
/// Write the element with it's <c>xs:boolean</c> value
/// </summary>
/// <param name="namespacePrefix">
/// The namespace prefix
/// </param>
/// <param name="element">
/// The element name
/// </param>
/// <param name="value">
/// The elements text
/// </param>
protected void WriteElement(NamespacePrefixPair namespacePrefix, string element, int value)
{
this._writer.WriteElementString(
namespacePrefix.Prefix, element, namespacePrefix.NS, XmlConvert.ToString(value));
}
/// <summary>
/// Write the element with it's <c>xs:boolean</c> value
/// </summary>
/// <param name="namespacePrefix">
/// The namespace prefix
/// </param>
/// <param name="element">
/// The element name
/// </param>
/// <param name="value">
/// The elements text
/// </param>
protected void WriteElement(NamespacePrefixPair namespacePrefix, ElementNameTable element, int value)
{
this.WriteElement(namespacePrefix, NameTableCache.GetElementName(element), value);
}
/// <summary>
/// Write the element if it's value is not empty or null
/// </summary>
/// <param name="namespacePrefix">
/// The namespace prefix pair
/// </param>
/// <param name="element">
/// The <see cref="ElementNameTable"/> element name
/// </param>
/// <param name="value">
/// The elements text
/// </param>
protected void TryToWriteElement(NamespacePrefixPair namespacePrefix, ElementNameTable element, string value)
{
this.TryToWriteElement(namespacePrefix, NameTableCache.GetElementName(element), value);
}
/// <summary>
/// Write a Start Element to the given XmlTextWriter using the given prefix and the <see cref="ElementNameTable"/> name
/// </summary>
/// <param name="ns">
/// The namespace and prefix
/// </param>
/// <param name="element">
/// The <see cref="ElementNameTable"/> element name
/// </param>
protected void WriteStartElement(NamespacePrefixPair ns, string element)
{
this._writer.WriteStartElement(ns.Prefix, element, ns.NS);
}
/// <summary>
/// Write the element if it's value is not empty or null
/// </summary>
/// <param name="namespacePrefix">
/// The namespace prefix pair
/// </param>
/// <param name="element">
/// The <see cref="ElementNameTable"/> element name
/// </param>
/// <param name="value">
/// The elements text
/// </param>
protected void TryToWriteElement(NamespacePrefixPair namespacePrefix, string element, string value)
{
if (!string.IsNullOrEmpty(value))
{
this.WriteElement(namespacePrefix, element, value);
}
}
/// <summary>
/// This is an internal method that is used to write the <paramref name="textObject"/>
/// The method create a xml element named by the name parameter.
/// It will only write the xml element if the text inside <paramref name="textObject"/> is not null or empty
/// </summary>
/// <param name="namespacePrefix">
/// The namespace prefix pair
/// </param>
/// <param name="textObject">
/// The <see cref="KeyValuePair{TKey,TValue}"/> object containing the data to be written, where key is the locale and value the text value
/// </param>
/// <param name="name">
/// The name of the xml element
/// </param>
protected void WriteTextType(
NamespacePrefixPair namespacePrefix, IDictionary<string, string> textObject, ElementNameTable name)
{
foreach (KeyValuePair<string, string> valuePair in textObject)
{
this.WriteTextType(namespacePrefix, valuePair, name);
}
}
/// <summary>
/// Write the element with it's <c>xs:boolean</c> value if it is true
/// </summary>
/// <param name="prefix">
/// The namespace prefix
/// </param>
/// <param name="element">
/// The <see cref="ElementNameTable"/> element name
/// </param>
/// <param name="value">
/// The elements text
/// </param>
protected void TryToWriteElement(NamespacePrefixPair prefix, ElementNameTable element, bool value)
{
if (value)
{
this.WriteElement(prefix, element, true);
}
}
/// <summary>
/// This is an internal method that is used to write the <paramref name="textObject"/>
/// The method create a xml element named by the name parameter.
/// It will only write the xml element if the text inside <paramref name="textObject"/> is not null or empty
/// </summary>
/// <param name="namespacePrefix">
/// The namespace Prefix.
/// </param>
/// <param name="textObject">
/// The <see cref="KeyValuePair{TKey,TValue}"/> object containing the data to be written, where key is the locale and value the text value
/// </param>
/// <param name="name">
/// The name of the xml element
/// </param>
protected void WriteTextType(
NamespacePrefixPair namespacePrefix, KeyValuePair<string, string> textObject, ElementNameTable name)
{
this.WriteTextType(namespacePrefix, name, textObject.Value, textObject.Key);
}
/// <summary>
/// Set the top element namespace prefix
/// </summary>
/// <param name="namespaceUri">
/// The namespace URI
/// </param>
internal void SetTopElementsNS(NamespacePrefixPair namespaceUri)
{
this._rootNamespace = namespaceUri;
}
/// <summary>
/// This is an internal method that is used to write a <see cref="ITextTypeWrapper" />
/// The method create a XML element named by the name parameter.
/// It will only write the XML element if the <see cref="ITextTypeWrapper.Value" /> is not null or empty
/// </summary>
/// <param name="namespacePrefix">The namespace prefix that should be used</param>
/// <param name="textObject">The text object.</param>
/// <param name="name">The name.</param>
protected void WriteTextType(NamespacePrefixPair namespacePrefix, IList<ITextTypeWrapper> textObject, ElementNameTable name)
{
if (textObject != null && textObject.Count > 0)
{
this.WriteTextType(namespacePrefix, textObject[0], name);
}
}
/// <summary>
/// This method is used to write the root xml tag and *Data tag
/// with their corresponding attributes
/// </summary>
/// <param name="element">
/// The first element tag name
/// </param>
/// <param name="namespaces">
/// The namespaces used by sdmx that are
/// appended by this method as attributes of the *Data tag
/// </param>
protected void WriteMessageTag(string element, SdmxNamespaces namespaces)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
// <?xml version="1.0" encoding="UTF-8"?>
if (!this.Wrapped)
{
this.SdmxMLWriter.WriteStartDocument();
}
// Generated File comment
if (!string.IsNullOrEmpty(this._generatedFileComment))
{
this.SdmxMLWriter.WriteComment(this._generatedFileComment);
}
// <CompactData
this.WriteStartElement(this.Namespaces.Message, element);
// xmlns="http://www.SDMX.org/resources/SDMXML/schemas/v2_0/message"
this.WriteNamespaceDecl(this.Namespaces.Message);
if (string.IsNullOrEmpty(this._namespacePrefix))
{
this._namespacePrefix = string.Format(
CultureInfo.InvariantCulture, "{0}{1}", PrefixConstants.DataSetStructureSpecific, this._prefixCount);
this._prefixCount++;
}
switch (this.DataFormatType)
{
case BaseDataFormatEnumType.Generic:
this._dataSetNS = this.Namespaces.Generic;
break;
case BaseDataFormatEnumType.Compact:
case BaseDataFormatEnumType.CrossSectional:
this._dataSetNS = this._namespace == null
? this.BuildDSDSpecificUrn(this._namespacePrefix)
: new NamespacePrefixPair(this._namespace, this._namespacePrefix);
this.Namespaces.DataSetStructureSpecific = this._dataSetNS;
break;
}
this.WriteNamespaceDecl(this._dataSetNS);
// xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
this.WriteNamespaceDecl(this.Namespaces.Xsi);
// xsi:schemaLocation="http://www.SDMX.org/resources/SDMXML/schemas/v2_0/message SDMXMessage.xsd">
string schemaLocation = this.Namespaces.SchemaLocation ?? string.Empty;
string structureSpecific = this.GetSchemaLocation(this.TargetSchema.EnumType);
if (!string.IsNullOrWhiteSpace(structureSpecific))
{
schemaLocation = string.Format(
CultureInfo.InvariantCulture, "{0} {1}", schemaLocation, structureSpecific);
}
if (!string.IsNullOrWhiteSpace(schemaLocation))
{
this.WriteAttributeString(this.Namespaces.Xsi, XmlConstants.SchemaLocation, schemaLocation);
}
}
/// <summary>
/// This is an internal method that is used to write a <see cref="ITextTypeWrapper"/>
/// The method create a xml element named by the name parameter.
/// It will only write the xml element if the <see cref="ITextTypeWrapper.Value"/> is not null or empty
/// </summary>
/// <param name="namespacePrefix">
/// The namespace prefix that should be used
/// </param>
/// <param name="textObject">
/// The <see cref="ITextTypeWrapper"/> object containing the data to be written
/// </param>
/// <param name="name">
/// The name of the xml element
/// </param>
protected void WriteTextType(
NamespacePrefixPair namespacePrefix, ITextTypeWrapperMutableObject textObject, ElementNameTable name)
{
string value = textObject.Value;
string locale = textObject.Locale;
this.WriteTextType(namespacePrefix, name, value, locale);
}
/// <summary>
/// Starts a dataset with the data conforming to the DSD
/// </summary>
/// <param name="dataflow">Optional. The dataflow can be provided to give extra information about the dataset.</param>
/// <param name="dsd">The <see cref="IDataStructureObject" /> for which the dataset will be created</param>
/// <param name="header">The <see cref="IHeader" /> of the dataset</param>
/// <param name="annotations">Any additional annotations that are attached to the dataset, can be null if no annotations exist</param>
/// <exception cref="System.ArgumentNullException">if the <paramref name="dsd" /> is null</exception>
public override void StartDataset(IDataflowObject dataflow, IDataStructureObject dsd, IDatasetHeader header, params IAnnotation[] annotations)
{
base.StartDataset(dataflow, dsd, header, annotations);
this._primaryMeasureConcept = this.GetComponentId(dsd.PrimaryMeasure);
this._compactNs = this.TargetSchema.EnumType != SdmxSchemaEnumType.VersionTwoPointOne
? this.Namespaces.DataSetStructureSpecific
: NamespacePrefixPair.Empty;
this._obsConcept = this.IsTwoPointOne
? this.DimensionAtObservation
: ConceptRefUtil.GetConceptId(this.KeyFamily.TimeDimension.ConceptRef);
if (this.IsTwoPointOne)
{
this.WriteAnnotations(ElementNameTable.AnnotationType, annotations);
}
else
{
this._datasetAnnotations = annotations;
}
}
/// <summary>
/// Write the list contacts.
/// </summary>
/// <param name="namespacePrefixPair">
/// The namespace prefix pair.
/// </param>
/// <param name="element">
/// The element.
/// </param>
/// <param name="list">
/// The list.
/// </param>
private void WriteListContacts(
NamespacePrefixPair namespacePrefixPair, ElementNameTable element, IEnumerable<string> list)
{
foreach (string value in list)
{
if (!string.IsNullOrWhiteSpace(value))
{
this.WriteElement(namespacePrefixPair, element, value);
}
}
}