/////////////////////////////////////////////////////////////////////////////////////////////////// ////////////BUILD FROM MUTABLE OBJECTS ////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////// #region Constructors and Destructors /// <summary> /// Initializes a new instance of the <see cref="CrossSectionalMeasureCore"/> class. /// </summary> /// <param name="itemMutableObject"> /// The itemMutableObject. /// </param> /// <param name="parent"> /// The parent. /// </param> /// <exception cref="SdmxSemmanticException"> /// Throws Validate exception. /// </exception> public CrossSectionalMeasureCore( ICrossSectionalMeasureMutableObject itemMutableObject, ICrossSectionalDataStructureObject parent) : base(itemMutableObject, parent) { this.measureDimension = itemMutableObject.MeasureDimension; this.code = itemMutableObject.Code; try { this.Validate(); } catch (SdmxSemmanticException ex) { throw new SdmxSemmanticException(ex, ExceptionCode.ObjectStructureConstructionError, this.Urn); } catch (Exception th) { throw new SdmxException(th, ExceptionCode.ObjectStructureConstructionError, this.Urn); } }
/// <summary> /// Determines the current data structure. /// </summary> /// <exception cref="SdmxNoResultsException"> /// Could not read dataset, the data set references dataflow '+errorString+' which could not be resolved /// or /// Could not read dataset, the data set references provision '+errorString+' which could not be resolved /// or /// Could not read dataset, the data set references dataflow '+errorString+' which could not be resolved /// or /// Can not read dataset, the data set references the DSD ' + errorString + ' which could not be resolved /// or /// Can not read dataset, the data set does no reference any data structures, and there was no default data structure /// definition provided /// </exception> /// <exception cref="SdmxNotImplementedException">Can not write dataset for structure of type: + sRef</exception> private void DetermineCurrentDataStructure() { // 1. Set the current DSD to null before trying to resolve it this._currentDsd = null; this._currentDataflow = null; IDatasetStructureReference datasetStructureReference = null; if (this._datasetHeader != null) { datasetStructureReference = this._datasetHeader.DataStructureReference; if (datasetStructureReference == null && this._headerObject != null && this._headerObject.Structures.Count == 1) { datasetStructureReference = this._headerObject.Structures[0]; } } if (datasetStructureReference != null) { var structureReference = datasetStructureReference.StructureReference; string errorString = structureReference.MaintainableReference.ToString(); // Provision, Flow, DSD or MSD switch (structureReference.TargetReference.EnumType) { case SdmxStructureEnumType.Dsd: if (this._defaultDsd != null && structureReference.IsMatch(this._defaultDsd)) { this.SetCurrentDsd(this._defaultDsd); } else if (this._objectRetrieval != null) { this.SetCurrentDsd(structureReference.MaintainableReference); } break; case SdmxStructureEnumType.Dataflow: if (this._objectRetrieval != null) { this._currentDataflow = this._objectRetrieval.GetMaintainableObject<IDataflowObject>(structureReference.MaintainableReference); if (this._currentDataflow == null) { throw new SdmxNoResultsException("Could not read dataset, the data set references dataflow '" + errorString + "' which could not be resolved"); } this.SetCurrentDsd(this._currentDataflow.DataStructureRef.MaintainableReference); } else { // Use the "header" values this.SetCurrentDsd(this._defaultDsd); this._currentDataflow = this._dataflow; } break; default: throw new SdmxNotImplementedException("Can not write dataset for structure of type: " + structureReference); } if (this._currentDsd == null) { throw new SdmxNoResultsException("Can not read dataset, the data set references the DSD '" + errorString + "' which could not be resolved"); } } else if (this._defaultDsd == null) { throw new SdmxNoResultsException("Can not read dataset, the data set does no reference any data structures, and there was no default data structure definition provided"); } else { if (this._dataflow != null) { this.SetCurrentDataflow(this._dataflow); } else { this.SetCurrentDsd(this._defaultDsd); } } }
/// <summary> /// Sets the current DSD. /// </summary> /// <param name="currentDsd"> /// The current DSD. /// </param> protected void SetCurrentDsd(ICrossSectionalDataStructureObject currentDsd) { this._currentDsd = currentDsd; foreach (var component in currentDsd.Components) { this._conceptToComponentId[component.ConceptRef.FullId] = component.Id; } this._availableDimensions.AddRange(currentDsd.GetDimensions(SdmxStructureEnumType.Dimension).Select(dimension => dimension.Id)); this._availableMeasureDimensions.AddRange(currentDsd.GetDimensions(SdmxStructureEnumType.MeasureDimension).Select(dimension => dimension.Id)); this._availableCrossSectionalMeasures.AddRange(currentDsd.CrossSectionalMeasures.Select(measure => measure.Id)); this._primaryMeasure = currentDsd.PrimaryMeasure.Id; if (currentDsd.TimeDimension != null) { this._timeDimensionId = currentDsd.TimeDimension.Id; } // If the current dataset header does not reference a DSD then amend it var datasetHeader = this._datasetHeader; if (datasetHeader != null && datasetHeader.DataStructureReference == null) { IDatasetStructureReference datasetStructureReference = new DatasetStructureReferenceCore(currentDsd.AsReference); this._datasetHeader = this._datasetHeader.ModifyDataStructureReference(datasetStructureReference); } }
/// <summary> /// Initializes a new instance of the <see cref="CrossSectionalDataReaderEngine"/> class. /// </summary> /// <param name="dataLocation"> /// The data location. /// </param> /// <param name="objectRetrieval"> /// The object retrieval. /// </param> /// <param name="defaultDsd"> /// The DSD. giving the ability to retrieve DSDs for the datasets this reader engine is reading. This /// can be null if there is only one relevant DSD - in which case the default DSD should be provided /// </param> /// <param name="dataflow"> /// The dataflow. /// </param> public CrossSectionalDataReaderEngine(IReadableDataLocation dataLocation, ISdmxObjectRetrievalManager objectRetrieval, ICrossSectionalDataStructureObject defaultDsd, IDataflowObject dataflow) { this._xmlBuilder = new XmlReaderBuilder(); if (objectRetrieval == null && defaultDsd == null) { throw new ArgumentException("AbstractDataReaderEngine expects either a ISdmxObjectRetrievalManager or a IDataStructureObject to be able to interpret the structures"); } this._objectRetrieval = objectRetrieval; this._dataLocation = dataLocation; this._defaultDsd = defaultDsd; this._dataflow = dataflow; this.Reset(); }
/// <summary> /// Initializes a new instance of the <see cref="CrossSectionalDataReaderEngine"/> class. /// </summary> /// <param name="dataLocation"> /// The data location. /// </param> /// <param name="dsd"> /// The DSD. giving the ability to retrieve DSDs for the datasets this reader engine is reading. This /// can be null if there is only one relevant DSD - in which case the default DSD should be provided /// </param> /// <param name="dataflow"> /// The dataflow. /// </param> public CrossSectionalDataReaderEngine(IReadableDataLocation dataLocation, ICrossSectionalDataStructureObject dsd, IDataflowObject dataflow) : this(dataLocation, null, dsd, dataflow) { }
/// <summary> /// Starts a dataset with the data conforming to the <paramref name="dsd"/> /// </summary> /// <param name="dataflow"> /// The <see cref="IDataflowObject"/> /// </param> /// <param name="dsd"> /// The <see cref="ICrossSectionalDataStructureObject"/> /// </param> /// <param name="header"> /// The Dataset attributes /// </param> /// <exception cref="System.ArgumentNullException"> /// if the <paramref name="dsd"/> is null /// </exception> public void StartDataset(IDataflowObject dataflow, ICrossSectionalDataStructureObject dsd, IDatasetHeader header) { if (dsd == null) { throw new ArgumentNullException("dsd"); } base.StartDataset(null, dsd, header); }
/// <summary> /// Starts a dataset with the data conforming to the <paramref name="dsd" /> /// </summary> /// <param name="dataflow">The <see cref="T:Org.Sdmxsource.Sdmx.Api.Model.Objects.DataStructure.IDataflowObject" /></param> /// <param name="dsd">The <see cref="T:Org.Sdmxsource.Sdmx.Api.Model.Objects.DataStructure.ICrossSectionalDataStructureObject" /></param> /// <param name="header">The Dataset attributes</param> /// <exception cref="T:System.ArgumentNullException">if the <paramref name="dsd" /> is null</exception> public void StartDataset(IDataflowObject dataflow, ICrossSectionalDataStructureObject dsd, IDatasetHeader header) { switch (this._delayBehavior) { case DataWriterDelayBehavior.UntilFirstStartDataSet: this.RunQueue(); this._dataWriterEngine.StartDataset(dataflow, dsd, header); break; default: this._actions.Enqueue(() => this._dataWriterEngine.StartDataset(dataflow, dsd, header)); break; } }
/// <summary> /// Writes the cross data. /// </summary> /// <param name="outputFileName"> /// Name of the output file. /// </param> /// <param name="crossSectionalDataStructureObject"> /// The cross sectional data structure object. /// </param> private static void WriteCrossDataNoTimeMeasure(string outputFileName, ICrossSectionalDataStructureObject crossSectionalDataStructureObject) { using (XmlWriter writer = XmlWriter.Create(outputFileName, new XmlWriterSettings { Indent = true })) using (ICrossSectionalWriterEngine crossSectionalWriter = new CrossSectionalWriterEngine(writer, SdmxSchema.GetFromEnum(SdmxSchemaEnumType.VersionTwo))) { crossSectionalWriter.WriteHeader(new HeaderImpl("TEST_ID", "TEST_SENDER")); crossSectionalWriter.StartDataset(null, crossSectionalDataStructureObject, null); crossSectionalWriter.StartXSGroup(); crossSectionalWriter.WriteXSGroupKeyValue("FREQ", "Q"); crossSectionalWriter.StartSection(); crossSectionalWriter.WriteSectionKeyValue("ADJUSTMENT", "N"); crossSectionalWriter.StartXSObservation("A", "1"); crossSectionalWriter.WriteAttributeValue("DECIMALS", "3"); crossSectionalWriter.StartXSObservation("B", "2"); crossSectionalWriter.WriteAttributeValue("DECIMALS", "3"); } }
/// <summary> /// Initializes a new instance of the <see cref="CrossSectionalDataStructureMutableCore"/> class. /// </summary> /// <param name="objTarget"> /// The obj target. /// </param> public CrossSectionalDataStructureMutableCore(ICrossSectionalDataStructureObject objTarget) : base(objTarget) { this._crossSectionalMeasures = new List<ICrossSectionalMeasureMutableObject>(); this._crossSectionalAttachDataSet = new List<string>(); this._crossSectionalAttachGroup = new List<string>(); this._crossSectionalAttachSection = new List<string>(); this._crossSectionalAttachObservation = new List<string>(); this._attributeToMeasureMap = new DictionaryOfLists<string, string>(StringComparer.Ordinal); PopulateList(this._crossSectionalAttachDataSet, objTarget.GetCrossSectionalAttachDataSet(false)); PopulateList(this._crossSectionalAttachGroup, objTarget.GetCrossSectionalAttachGroup(false)); PopulateList(this._crossSectionalAttachObservation, objTarget.GetCrossSectionalAttachObservation()); PopulateList(this._crossSectionalAttachSection, objTarget.GetCrossSectionalAttachSection(false)); foreach (IAttributeObject attribute in objTarget.Attributes) { IList<string> measureIds = new List<string>(); foreach (ICrossSectionalMeasure xsMeasure in objTarget.GetAttachmentMeasures(attribute)) { measureIds.Add(xsMeasure.Id); } this._attributeToMeasureMap.Add(attribute.Id, measureIds); } foreach (ICrossSectionalMeasure measure in objTarget.CrossSectionalMeasures) { this._crossSectionalMeasures.Add(new CrossSectionalMeasureMutableCore(measure)); } foreach (var dimension in objTarget.GetDimensions(SdmxStructureEnumType.MeasureDimension)) { var codelistForMeasureDimension = objTarget.GetCodelistForMeasureDimension(dimension.Id); if (codelistForMeasureDimension != null) { this._measureCodelistMapping[dimension.Id] = codelistForMeasureDimension.CreateMutableInstance(); } } }
/// <summary> /// Starts a dataset with the data conforming to the <paramref name="dsd" /> /// </summary> /// <param name="dataflow">The <see cref="T:Org.Sdmxsource.Sdmx.Api.Model.Objects.DataStructure.IDataflowObject" /></param> /// <param name="dsd">The <see cref="T:Org.Sdmxsource.Sdmx.Api.Model.Objects.DataStructure.ICrossSectionalDataStructureObject" /></param> /// <param name="header">The Dataset attributes</param> /// <exception cref="T:System.ArgumentNullException">if the <paramref name="dsd" /> is null</exception> public void StartDataset(IDataflowObject dataflow, ICrossSectionalDataStructureObject dsd, IDatasetHeader header) { this._actions.Enqueue(() => this._dataWriterEngine.StartDataset(dataflow, dsd, header)); }
/// <summary> /// Starts a dataset with the data conforming to the <paramref name="dsd" /> /// </summary> /// <param name="dataflow">The <see cref="T:Org.Sdmxsource.Sdmx.Api.Model.Objects.DataStructure.IDataflowObject" /></param> /// <param name="dsd">The <see cref="T:Org.Sdmxsource.Sdmx.Api.Model.Objects.DataStructure.ICrossSectionalDataStructureObject" /></param> /// <param name="header">The Dataset attributes</param> /// <exception cref="T:System.ArgumentNullException">if the <paramref name="dsd" /> is null</exception> public void StartDataset(IDataflowObject dataflow, ICrossSectionalDataStructureObject dsd, IDatasetHeader header) { this._actions.Enqueue(() => this._dataWriterEngine.StartDataset(dataflow, dsd, header)); }