/// <summary> /// Normalizes the SDMXV20 data structure. /// </summary> /// <param name="crossDsd">The cross DSD.</param> public static void NormalizeSdmxv20DataStructure(this ICrossSectionalDataStructureMutableObject crossDsd) { crossDsd.ConvertToStub(); var annotation = CustomAnnotationType.SDMXv20Only.ToAnnotation <AnnotationMutableCore>(); crossDsd.AddAnnotation(annotation); }
/// <summary> /// Convert measure representation from SDMX v2.0 to SDMX v2.1 and <see cref="ICrossSectionalDataStructureObject"/>. /// </summary> /// <param name="crossSectionalDataStructure"> /// The cross sectional data structure. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="crossSectionalDataStructure"/> is null /// </exception> /// <remarks> /// HACK HORIBLE HACK /// in 2.0 measure dimensions have a codelist based representation. On 2.1 have concept scheme based representation. /// </remarks> public static void ConvertMeasureRepresentation(ICrossSectionalDataStructureMutableObject crossSectionalDataStructure) { if (crossSectionalDataStructure == null) { throw new ArgumentNullException("crossSectionalDataStructure"); } IDimensionMutableObject measureDim = crossSectionalDataStructure.Dimensions.FirstOrDefault(o => o.MeasureDimension); if (measureDim != null && crossSectionalDataStructure.CrossSectionalMeasures.Count > 0) { IStructureReference crossSectionalMeasureConceptRef = crossSectionalDataStructure.CrossSectionalMeasures[0].ConceptRef; IDictionary<string, IStructureReference> measureDimensionCodelistMapping = crossSectionalDataStructure.MeasureDimensionCodelistMapping; IStructureReference cocneptSchemeRef = new StructureReferenceImpl( crossSectionalMeasureConceptRef.MaintainableReference, SdmxStructureType.GetFromEnum(SdmxStructureEnumType.ConceptScheme)); measureDimensionCodelistMapping.Add(measureDim.Id ?? measureDim.ConceptRef.ChildReference.Id, measureDim.Representation.Representation); measureDim.Representation.Representation = cocneptSchemeRef; } }
/// <summary> /// Setup cross sectional DSD. /// </summary> /// <param name="parent"> /// The parent. /// </param> /// <param name="crossDataSet"> /// The list of components attached to cross-sectional data set. /// </param> /// <param name="crossGroup"> /// The list of components attached to cross-sectional group. /// </param> /// <param name="crossSection"> /// The list of components attached to cross-sectional section. /// </param> /// <param name="crossObs"> /// The list of components attached to cross-sectional observation level /// </param> /// <param name="crossSectionalMeasures"> /// The cross sectional measures. /// </param> /// <param name="measureCodelistRepresentation"> /// The SDMX v2.0 measure dimension codelist representation; otherwise null /// </param> /// <returns> /// The <see cref="IDataStructureMutableObject"/>. /// </returns> private static IDataStructureMutableObject SetupCrossSectionalDsd( IDataStructureMutableObject parent, ICollection <string> crossDataSet, ICollection <string> crossGroup, ICollection <string> crossSection, ICollection <string> crossObs, IEnumerable <ICrossSectionalMeasureMutableObject> crossSectionalMeasures, IStructureReference measureCodelistRepresentation) { if ( parent.Dimensions.All( o => o.FrequencyDimension || o.TimeDimension || o.MeasureDimension || crossDataSet.Contains(o.Id) || crossGroup.Contains(o.Id) || crossSection.Contains(o.Id) || crossObs.Contains(o.Id))) { if (parent.AttributeList == null || parent.AttributeList.Attributes.All(o => crossDataSet.Contains(o.Id) || crossGroup.Contains(o.Id) || crossSection.Contains(o.Id) || crossObs.Contains(o.Id))) { ICrossSectionalDataStructureMutableObject crossDsd = _crossDsdBuilder.Build(parent); crossDsd.CrossSectionalAttachDataSet.AddAll(crossDataSet); crossDsd.CrossSectionalAttachSection.AddAll(crossSection); crossDsd.CrossSectionalAttachGroup.AddAll(crossGroup); crossDsd.CrossSectionalAttachObservation.AddAll(crossObs); IDimensionMutableObject measure = crossDsd.Dimensions.FirstOrDefault(o => o.MeasureDimension); if (measure != null) { foreach (ICrossSectionalMeasureMutableObject crossSectionalMeasureMutableObject in crossSectionalMeasures) { crossSectionalMeasureMutableObject.MeasureDimension = measure.Id; crossDsd.CrossSectionalMeasures.Add(crossSectionalMeasureMutableObject); } if (measureCodelistRepresentation == null) { DataStructureUtil.ConvertMeasureRepresentation(crossDsd); } } return(crossDsd); } } return(parent); }
/// <summary> /// Setups the group attributes. /// </summary> /// <param name="dataStructure">The data structure.</param> /// <param name="dsdId">The DSD identifier.</param> private void SetupAttributesAttachmentCrossMeasures(ICrossSectionalDataStructureMutableObject dataStructure, long dsdId) { if (dataStructure == null || !ObjectUtil.ValidCollection(dataStructure.Attributes) || !ObjectUtil.ValidCollection(dataStructure.CrossSectionalMeasures)) { return; } var idToAttribureMap = dataStructure.Attributes.Where(o => dataStructure.CrossSectionalAttachObservation.Contains(o.Id)).ToDictionary(o => o.Id, StringComparer.Ordinal); if (idToAttribureMap.Count == 0) { return; } using (DbCommand command = this._commandBuilder.Build(new ItemSqlQuery(this._attributeMeasureQueryInfo, dsdId))) { using (IDataReader dataReader = this.MappingStoreDb.ExecuteReader(command)) { while (dataReader.Read()) { var measureId = DataReaderHelper.GetString(dataReader, "XSM_ID"); var attributeId = DataReaderHelper.GetString(dataReader, "ATTR_ID"); IAttributeMutableObject attribute; if (idToAttribureMap.TryGetValue(attributeId, out attribute)) { Debug.Assert(attribute != null, "BUG. Attribute is null"); IList <string> measures; if (!dataStructure.AttributeToMeasureMap.TryGetValue(attributeId, out measures)) { measures = new List <string>(); dataStructure.AttributeToMeasureMap.Add(attributeId, measures); } measures.Add(measureId); } else { _log.WarnFormat("Attribute with ID {0} of DSD {1} has measure mappings but its attachment level is not observation", attributeId, dataStructure.Id); } } } } }
/// <summary> /// Converts the specified <paramref name="crossDsd"/> to stub. /// </summary> /// <param name="crossDsd">The cross DSD.</param> public static void ConvertToStub(this ICrossSectionalDataStructureMutableObject crossDsd) { crossDsd.Stub = true; crossDsd.ExternalReference = TertiaryBool.GetFromEnum(TertiaryBoolEnumType.True); crossDsd.StructureURL = _defaultUri; // remove components crossDsd.AttributeList = null; crossDsd.DimensionList = new DimensionListMutableCore(); crossDsd.Dimensions.Clear(); crossDsd.Groups.Clear(); crossDsd.MeasureList = null; crossDsd.CrossSectionalAttachDataSet.Clear(); crossDsd.CrossSectionalAttachGroup.Clear(); crossDsd.CrossSectionalAttachSection.Clear(); crossDsd.CrossSectionalAttachObservation.Clear(); crossDsd.CrossSectionalMeasures.Clear(); crossDsd.MeasureDimensionCodelistMapping.Clear(); crossDsd.AttributeToMeasureMap.Clear(); }
/// <summary> /// Builds an object of type <see cref="IDataStructureMutableObject"/> from the specified <paramref name="buildFrom"/> /// </summary> /// <param name="buildFrom"> /// An <see cref="ICrossSectionalDataStructureMutableObject"/> object to build the output object from /// </param> /// <returns> /// Object of type <see cref="IDataStructureMutableObject"/> /// </returns> public IDataStructureMutableObject Build(ICrossSectionalDataStructureMutableObject buildFrom) { var imutableDsd = new DataStructureObjectCore(buildFrom); return new DataStructureMutableCore(imutableDsd); }
/// <summary> /// Initializes a new instance of the <see cref="CrossSectionalDsdHelper"/> class. /// </summary> /// <param name="dsd"> /// The DSD. /// </param> public CrossSectionalDsdHelper(IDataStructureMutableObject dsd) { this._crossSectional = dsd as ICrossSectionalDataStructureMutableObject; if (this._crossSectional != null) { this._crossDataSet = new HashSet<string>( this._crossSectional.CrossSectionalAttachDataSet, StringComparer.Ordinal); this._crossGroup = new HashSet<string>( this._crossSectional.CrossSectionalAttachGroup, StringComparer.Ordinal); this._crossSection = new HashSet<string>( this._crossSectional.CrossSectionalAttachSection, StringComparer.Ordinal); this._crossObs = new HashSet<string>( this._crossSectional.CrossSectionalAttachObservation, StringComparer.Ordinal); this._attributeMap = this._crossSectional.AttributeToMeasureMap; } }
/// <summary> /// Initializes a new instance of the <see cref="CrossSectionalDataStructureObjectCore"/> class. /// </summary> /// <param name="itemMutableObject"> /// The itemMutableObject. /// </param> /// <exception cref="SdmxSemmanticException"> /// Throws Validate exception. /// </exception> public CrossSectionalDataStructureObjectCore(ICrossSectionalDataStructureMutableObject itemMutableObject) : base(itemMutableObject) { this._crossSectionalMeasures = new List<ICrossSectionalMeasure>(); this._crossSectionalAttachDataSet = new List<IComponent>(); this._crossSectionalAttachGroup = new List<IComponent>(); this._crossSectionalAttachSection = new List<IComponent>(); this._crossSectionalAttachObservation = new List<IComponent>(); this._attributeToMeasuresMap = new Dictionary<string, IList<ICrossSectionalMeasure>>(); this._measureDimensions = new List<string>(); this._codelistMap = new Dictionary<string, ICrossReference>(); if (itemMutableObject.CrossSectionalMeasures != null) { foreach (ICrossSectionalMeasureMutableObject currentMeasure in itemMutableObject.CrossSectionalMeasures) { this._crossSectionalMeasures.Add(new CrossSectionalMeasureCore(currentMeasure, this)); } } if (itemMutableObject.MeasureDimensionCodelistMapping != null) { foreach (KeyValuePair<string, IStructureReference> pair in itemMutableObject.MeasureDimensionCodelistMapping) { this._codelistMap.Add(pair.Key, new CrossReferenceImpl(this, pair.Value)); } } foreach (IDimensionMutableObject dim in itemMutableObject.Dimensions) { if (dim.MeasureDimension) { this._measureDimensions.Add(dim.ConceptRef.IdentifiableIds[0]); } } if (itemMutableObject.CrossSectionalAttachDataSet != null) { foreach (string componentId in itemMutableObject.CrossSectionalAttachDataSet) { this.AddComponentToList(componentId, this._crossSectionalAttachDataSet); } } if (itemMutableObject.CrossSectionalAttachGroup != null) { foreach (string componentId0 in itemMutableObject.CrossSectionalAttachGroup) { this.AddComponentToList(componentId0, this._crossSectionalAttachGroup); } } if (itemMutableObject.CrossSectionalAttachSection != null) { foreach (string componentId1 in itemMutableObject.CrossSectionalAttachSection) { this.AddComponentToList(componentId1, this._crossSectionalAttachSection); } } if (itemMutableObject.CrossSectionalAttachObservation != null) { foreach (string componentId2 in itemMutableObject.CrossSectionalAttachObservation) { this.AddComponentToList(componentId2, this._crossSectionalAttachObservation); } } if (itemMutableObject.AttributeToMeasureMap != null) { foreach (KeyValuePair<string, IList<string>> pair in itemMutableObject.AttributeToMeasureMap) { this.SetAttributeMeasures(pair.Key, pair.Value); } } 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> /// Handle end element. /// </summary> /// <param name="localname"> /// The element local name. /// </param> protected override void HandleEndElement(object localname) { if (NameTableCache.IsElement(localname, ElementNameTable.KeyFamily)) { Debug.Assert(this._currentDsd != null, "_currentDsd is null", "Local name: {0}", localname); if (this._currentDsd != null) { // do we have components attached to cross sectional levels ? if (IsCrossSectionalDsd(this._currentDsd)) { if (this._currentDsd.CrossSectionalMeasures.Count > 0) { DataStructureUtil.ConvertMeasureRepresentation(this._currentDsd); } this.Structure.AddDataStructure(this._currentDsd); } else { this.Structure.AddDataStructure(_builder.Build(this._currentDsd)); } this._currentDsd = null; } } }
/////// <summary> /////// Initialize handlers based on parent type for Elements and element text /////// </summary> ////private void InitializeTypeSwitch() ////{ //// // add element text handlers //// this.AddHandleText<IAttributeMutableObject>(this.HandleTextChildElement); //// this.AddHandleText<IGroupMutableObject>(this.HandleTextChildElement); //// this.AddHandleText<IAnnotationMutableObject>(this.HandleTextChildElement); //// this.AddHandleText<INameableMutableObject>( //// (parent, localName) => this.HandleCommonTextChildElement(parent, localName)); //// // add element handlers //// this.AddHandleElement<IComponentMutableObject>(this.HandleChildElements); //// this.AddHandleElement<ICrossSectionalDataStructureMutableObject>(this.HandleChildElements); //// this.AddHandleElement<ICollection<IAnnotationMutableObject>>(HandleChildElements); //// this.AddHandleElement<IdentifiableMutableCore>(HandleChildElements); // super type move last //// this.AddHandleElement<IMutableObjects>(this.HandleTopLevel); ////} /// <summary> /// Populates the properties of the given IAttributeMutableObject object from the given xml attributes dictionary /// </summary> /// <param name="parent"> /// The parent. /// </param> /// <param name="component"> /// The given IAttributeMutableObject object /// </param> /// <param name="attributes"> /// The dictionary contains the attributes of the element /// </param> private void ParseAttributes(ICrossSectionalDataStructureMutableObject parent, IAttributeMutableObject component, IDictionary<string, string> attributes) { ParseComponentBaseAttributes(parent, component, attributes); string attachmentLevel = Helper.TrySetFromAttribute(attributes, AttributeNameTable.attachmentLevel, string.Empty); if (attachmentLevel == "Series") { component.AttachmentLevel = AttributeAttachmentLevel.DimensionGroup; foreach (IDimensionMutableObject dimension in this._currentDsd.Dimensions) { if (!dimension.TimeDimension) { component.DimensionReferences.Add(dimension.ConceptRef.ChildReference.Id); } } } else { AttributeAttachmentLevel modelAttachementLevel; if (Enum.TryParse(attachmentLevel, out modelAttachementLevel)) { component.AttachmentLevel = modelAttachementLevel; } } component.AssignmentStatus = Helper.TrySetFromAttribute(attributes, AttributeNameTable.assignmentStatus, component.AssignmentStatus); //// TODO JAVA 0.9.9 missing TimeFormat property from IAttributeMutableObject. bool timeFormat = Helper.TrySetFromAttribute(attributes, AttributeNameTable.isTimeFormat, false); if (timeFormat) { //// TODO FIXME HACK because of missing TimeFormat property from java 0.9.9 component.Id = "TIME_FORMAT"; } //// TODO java not supported by the Common API as in Java version 0.9.9 ////component.IsEntityAttribute = Helper.TrySetFromAttribute( //// attributes, AttributeNameTable.isEntityAttribute, component.IsEntityAttribute); ////component.IsNonObservationalTimeAttribute = Helper.TrySetFromAttribute( //// attributes, AttributeNameTable.isNonObservationalTimeAttribute, component.IsNonObservationalTimeAttribute); ////component.IsCountAttribute = Helper.TrySetFromAttribute( //// attributes, AttributeNameTable.isCountAttribute, component.IsCountAttribute); ////component.IsFrequencyAttribute = Helper.TrySetFromAttribute( //// attributes, AttributeNameTable.isFrequencyAttribute, component.IsFrequencyAttribute); ////component.IsIdentityAttribute = Helper.TrySetFromAttribute( //// attributes, AttributeNameTable.isIdentityAttribute, component.IsIdentityAttribute); }
/// <summary> /// Handles the KeyFamily element child elements /// </summary> /// <param name="parent"> /// The parent IDataStructureMutableObject object /// </param> /// <param name="localName"> /// The name of the current xml element /// </param> /// <returns> /// The <see cref="StructureReaderBaseV20.ElementActions"/>. /// </returns> private ElementActions HandleChildElements(ICrossSectionalDataStructureMutableObject parent, object localName) { ElementActions actions = null; if (NameTableCache.IsElement(localName, ElementNameTable.Dimension)) { var dimension = new DimensionMutableCore(); ParseAttributes(parent, dimension, this.Attributes); parent.AddDimension(dimension); actions = this.BuildElementActions(dimension, this.HandleChildElements, DoNothing); } else if (NameTableCache.IsElement(localName, ElementNameTable.TimeDimension)) { var timeDimension = new DimensionMutableCore { TimeDimension = true, Id = DimensionObject.TimeDimensionFixedId }; ParseAttributes(parent, timeDimension, this.Attributes); parent.AddDimension(timeDimension); actions = this.BuildElementActions(timeDimension, this.HandleChildElements, DoNothing); } else if (NameTableCache.IsElement(localName, ElementNameTable.PrimaryMeasure)) { var measure = new PrimaryMeasureMutableCore(); ParseComponentBaseAttributes(parent, measure, this.Attributes); parent.PrimaryMeasure = measure; actions = this.BuildElementActions(measure, this.HandleChildElements, DoNothing); } else if (NameTableCache.IsElement(localName, ElementNameTable.CrossSectionalMeasure)) { var measure = new CrossSectionalMeasureMutableCore(); ParseAttributes(parent, measure, this.Attributes); parent.AddCrossSectionalMeasures(measure); actions = this.BuildElementActions(measure, this.HandleChildElements, DoNothing); } else if (NameTableCache.IsElement(localName, ElementNameTable.Attribute)) { var attribute = new AttributeMutableCore(); ParseAttributes(parent, attribute, this.Attributes); parent.AddAttribute(attribute); actions = this.BuildElementActions(attribute, this.HandleChildElements, this.HandleTextChildElement); } else if (NameTableCache.IsElement(localName, ElementNameTable.Components)) { //// Component element contains the rest of elements so we use the same action again. actions = this.BuildElementActions(parent, this.HandleChildElements, DoNothing); } else if (NameTableCache.IsElement(localName, ElementNameTable.Group)) { var groupMutableCore = new GroupMutableCore(); ParseAttributes(groupMutableCore, this.Attributes); parent.AddGroup(groupMutableCore); actions = this.BuildElementActions(groupMutableCore, this.HandleAnnotableChildElements, this.HandleTextChildElement); } return actions; }
/// <summary> /// Populates the properties of the given IComponentMutableObject object from the given xml attributes dictionary /// </summary> /// <param name="parent"> /// The <see cref="ICrossSectionalDataStructureMutableObject"/> /// </param> /// <param name="component"> /// The given IComponentMutableObject object /// </param> /// <param name="attributes"> /// The dictionary contains the attributes of the element /// </param> private static void ParseComponentBaseAttributes(ICrossSectionalDataStructureMutableObject parent, IComponentMutableObject component, IDictionary<string, string> attributes) { var conceptRef = ParseComponentConceptAttributes(component, attributes); // code list attributes string codelist = Helper.TrySetFromAttribute(attributes, AttributeNameTable.codelist, string.Empty); if (!string.IsNullOrEmpty(codelist)) { component.Representation = new RepresentationMutableCore(); string codelistVersion = Helper.TrySetFromAttribute(attributes, AttributeNameTable.codelistVersion, string.Empty); string codelistAgency = Helper.TrySetFromAttribute(attributes, AttributeNameTable.codelistAgency, string.Empty); component.Representation.Representation = new StructureReferenceImpl(codelistAgency, codelist, codelistVersion, SdmxStructureEnumType.CodeList); } // XS var id = component.Id ?? conceptRef; AddCrossSectionalAttach(id, parent.CrossSectionalAttachDataSet, AttributeNameTable.crossSectionalAttachDataSet, attributes); AddCrossSectionalAttach(id, parent.CrossSectionalAttachGroup, AttributeNameTable.crossSectionalAttachGroup, attributes); AddCrossSectionalAttach(id, parent.CrossSectionalAttachSection, AttributeNameTable.crossSectionalAttachSection, attributes); AddCrossSectionalAttach(id, parent.CrossSectionalAttachObservation, AttributeNameTable.crossSectionalAttachObservation, attributes); }
///// <summary> ///// Populates the proporties of the given IDimensionMutableObject object from the given xml attributes dictionary ///// </summary> ///// <param name="timeDimension">The given IDimensionMutableObject object</param> ///// <param name="attributes">The dictionary contains the attributes of the element</param> // private static void ParseAttributes(IDimensionMutableObject timeDimension, IDictionary<string, string> attributes) { // ParseAttributes((IComponentMutableObject) timeDimension, attributes); // } /// <summary> /// Populates the properties of the given IDimensionMutableObject object from the given xml attributes dictionary /// </summary> /// <param name="artefact"> /// The <see cref="ICrossSectionalDataStructureMutableObject"/> /// </param> /// <param name="dimension"> /// The given IDimensionMutableObject object /// </param> /// <param name="attributes"> /// The dictionary contains the attributes of the element /// </param> private static void ParseAttributes(ICrossSectionalDataStructureMutableObject artefact, IDimensionMutableObject dimension, IDictionary<string, string> attributes) { //// TODO java not supported by the Common API as in Java version 0.9.9 ////dimension.IsCountDimension = Helper.TrySetFromAttribute( //// attributes, AttributeNameTable.isCountAttribute, dimension.IsCountDimension); dimension.MeasureDimension = Helper.TrySetFromAttribute(attributes, AttributeNameTable.isMeasureDimension, dimension.MeasureDimension); dimension.FrequencyDimension = Helper.TrySetFromAttribute(attributes, AttributeNameTable.isFrequencyDimension, dimension.FrequencyDimension); //// TODO java not supported by the Common API as in Java version 0.9.9 ////dimension.IsEntityDimension = Helper.TrySetFromAttribute( //// attributes, AttributeNameTable.isEntityDimension, dimension.IsEntityDimension); ////dimension.IsNonObservationTimeDimension = Helper.TrySetFromAttribute( //// attributes, AttributeNameTable.isNonObservationTimeDimension, dimension.IsNonObservationTimeDimension); ////dimension.IsIdentityDimension = Helper.TrySetFromAttribute( //// attributes, AttributeNameTable.isIdentityAttribute, dimension.IsIdentityDimension); ParseComponentBaseAttributes(artefact, dimension, attributes); }
///// <summary> ///// Populates the proporties of the given IPrimaryMeasureMutableObject object from the given xml attributes dictionary ///// </summary> ///// <param name="measure">The given IPrimaryMeasureMutableObject objectt</param> ///// <param name="attributes">The dictionary contains the attributes of the element</param> // private static void ParseAttributes(IPrimaryMeasureMutableObject measure, IDictionary<string, string> attributes) { // ParseAttributes((IComponentMutableObject) measure, attributes); // } /// <summary> /// Populates the properties of the given ICrossSectionalMeasureMutableObject object from the given xml attributes dictionary /// </summary> /// <param name="artefact"> /// The <see cref="ICrossSectionalDataStructureMutableObject"/> /// </param> /// <param name="measure"> /// The given ICrossSectionalMeasureMutableObject object /// </param> /// <param name="attributes"> /// The dictionary contains the attributes of the element /// </param> private static void ParseAttributes(ICrossSectionalDataStructureMutableObject artefact, ICrossSectionalMeasureMutableObject measure, IDictionary<string, string> attributes) { ParseComponentBaseAttributes(artefact, measure, attributes); measure.MeasureDimension = Helper.TrySetFromAttribute(attributes, AttributeNameTable.measureDimension, measure.MeasureDimension); measure.Code = Helper.TrySetFromAttribute(attributes, AttributeNameTable.code, measure.Code); }
/// <summary> /// Checks if the current DSD is a valid SDMX v2.0 Cross Sectional DSD /// </summary> /// <param name="dsd"> /// The DSD. /// </param> /// <returns> /// Returns true if it is a valid SDMX v2.0 Cross Sectional DSD; otherwise false /// </returns> private static bool IsCrossSectionalDsd(ICrossSectionalDataStructureMutableObject dsd) { ISet<string> crossSectionalAttached = new HashSet<string>(dsd.CrossSectionalAttachDataSet); crossSectionalAttached.UnionWith(dsd.CrossSectionalAttachGroup); crossSectionalAttached.UnionWith(dsd.CrossSectionalAttachSection); crossSectionalAttached.UnionWith(dsd.CrossSectionalAttachObservation); IList<IDimensionMutableObject> dimensions = dsd.Dimensions; foreach (IDimensionMutableObject dimension in dimensions) { if (!dimension.FrequencyDimension && !dimension.MeasureDimension && !dimension.TimeDimension && !crossSectionalAttached.Contains(dimension.ConceptRef.ChildReference.Id)) { return false; } } if (dsd.AttributeList != null) { IList<IAttributeMutableObject> attributes = dsd.AttributeList.Attributes; foreach (IAttributeMutableObject attribute in attributes) { if (!crossSectionalAttached.Contains(attribute.ConceptRef.ChildReference.Id)) { return false; } } } return true; }
/// <summary> /// Handles the Structure top level elements /// This includes Codelist /// </summary> /// <param name="parent"> /// The parent <see cref="IMutableObjects"/> /// </param> /// <param name="localName"> /// The name of the current xml element /// </param> /// <returns> /// The <see cref="StructureReaderBaseV20.ElementActions"/>. /// </returns> protected override ElementActions HandleTopLevel(IMutableObjects parent, object localName) { ElementActions actions = null; if (NameTableCache.IsElement(localName, ElementNameTable.KeyFamily)) { var kf = new CrossSectionalDataStructureMutableCore(); ParseAttributes(kf, this.Attributes); //// NOTE this is handled at HandleEndElement because we need to decide if it will remain a XS DSD or should it be converted to a non XS (2.0) one. //// parent.AddDataStructure(kf); this._currentDsd = kf; actions = this.AddNameableAction(kf, this.HandleChildElements); } return actions; }