///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM MUTABLE OBJECTS //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
#region Constructors and Destructors
/// <summary>
/// Initializes a new instance of the <see cref="ComponentCore" /> class.
/// </summary>
/// <param name="itemMutableObject">The agencyScheme.</param>
/// <param name="parent">The parent.</param>
/// <param name="validateComponentAttributes">if set to <c>true</c> [validate component attributes].</param>
/// <exception cref="SdmxException">Throws Validate exception.</exception>
protected internal ComponentCore(IComponentMutableObject itemMutableObject, IIdentifiableObject parent, bool validateComponentAttributes = true)
: base(itemMutableObject, parent)
{
try
{
if (itemMutableObject.Representation != null)
{
this.LocalRepresentation = new RepresentationCore(itemMutableObject.Representation, this);
}
if (itemMutableObject.ConceptRef != null)
{
this._conceptRef = new CrossReferenceImpl(this, itemMutableObject.ConceptRef);
}
}
catch (Exception th)
{
throw new SdmxException("IsError creating component: " + this, th);
}
if (validateComponentAttributes)
{
this.ValidateComponentAttributes();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CrossReferenceException"/> class.
/// </summary>
/// <param name="crossReference">The cross reference</param>
public CrossReferenceException(ICrossReference crossReference)
: base(ExceptionCode.ReferenceErrorUnresolvable, GetReferenceFromIdentifier(crossReference), crossReference != null ? crossReference.TargetUrn : null)
{
if (crossReference == null)
{
throw new ArgumentNullException("crossReference");
}
this._crossReference = crossReference;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM MUTABLE OBJECTS //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
#region Constructors and Destructors
/// <summary>
/// Initializes a new instance of the <see cref="InputOutputCore"/> class.
/// </summary>
/// <param name="parent">
/// The parent.
/// </param>
/// <param name="mutableObject">
/// The mutable object.
/// </param>
public InputOutputCore(IIdentifiableObject parent, IInputOutputMutableObject mutableObject)
: base(mutableObject, parent)
{
this.localId = mutableObject.LocalId;
if (mutableObject.StructureReference != null)
{
this.structureReference = new CrossReferenceImpl(this, mutableObject.StructureReference);
}
this.Validate();
}
/// <summary>
/// Initializes a new instance of the <see cref="CodelistRefCore"/> class.
/// </summary>
/// <param name="codelistRefMutableObject">
/// The sdmxObject.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
public CodelistRefCore(ICodelistRefMutableObject codelistRefMutableObject, ISdmxStructure parent)
: base(codelistRefMutableObject, parent)
{
this.alias = codelistRefMutableObject.Alias;
if (codelistRefMutableObject.CodelistReference != null)
{
this.codelistReference = new CrossReferenceImpl(this, codelistRefMutableObject.CodelistReference);
}
this.Validate();
}
public GroupObjectBaseCore(IGroup group, IDataStructureObjectBase keyFamily) : base(group) {
this.dimension = new List<IDimensionObjectBase>();
this.dimensionMap = new Dictionary<String, IDimensionObjectBase>();
this.attachmentConstraintRef = group.AttachmentConstraintRef;
/* foreach */
foreach (String conceptId in group.DimensionRef) {
IDimensionObjectBase dim = keyFamily.GetDimensionById(conceptId);
dimension.Add(dim);
dimensionMap.Add(conceptId,dim);
}
this.id = group.Id;
}
public DataSetReferenceCore(SetReferenceType sRefType, IMetadataTargetKeyValues parent)
: base(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.DatasetReference), parent)
{
this._datasetId = sRefType.ID;
this._dataProviderReference = RefUtil.CreateReference(this, sRefType.DataProvider);
try
{
Validate();
}
catch (SdmxSemmanticException e)
{
throw new SdmxSemmanticException(e, ExceptionCode.FailValidation, this);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM MUTABLE OBJECT //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
#region Constructors and Destructors
/// <summary>
/// Initializes a new instance of the <see cref="RepresentationCore"/> class.
/// </summary>
/// <param name="representationMutableObject">
/// The sdmxObject.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
public RepresentationCore(IRepresentationMutableObject representationMutableObject, IIdentifiableObject parent)
: base(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.LocalRepresentation), parent)
{
if (representationMutableObject.TextFormat != null)
{
this.textFormat = new TextFormatObjectCore(representationMutableObject.TextFormat, this);
}
if (representationMutableObject.Representation != null)
{
this.representation = new CrossReferenceImpl(this, representationMutableObject.Representation);
}
this.Validate();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM MUTABLE OBJECT //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
#region Constructors and Destructors
/// <summary>
/// Initializes a new instance of the <see cref="ConceptCore"/> class.
/// </summary>
/// <param name="parent">
/// The parent.
/// </param>
/// <param name="itemMutableObject">
/// The sdmxObject.
/// </param>
public ConceptCore(IConceptSchemeObject parent, IConceptMutableObject itemMutableObject)
: base(itemMutableObject, parent)
{
if(itemMutableObject.CoreRepresentation != null && (itemMutableObject.CoreRepresentation.TextFormat != null || itemMutableObject.CoreRepresentation.Representation != null))
{
this.coreRepresentation = new RepresentationCore(itemMutableObject.CoreRepresentation, this);
}
if (itemMutableObject.IsoConceptReference != null)
{
this.isoConceptReference = new CrossReferenceImpl(this, itemMutableObject.IsoConceptReference);
}
this.parentConcept = itemMutableObject.ParentConcept;
this.parentAgency = itemMutableObject.ParentAgency;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM MUTABLE OBJECTS //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
#region Constructors and Destructors
/// <summary>
/// Initializes a new instance of the <see cref="GroupCore"/> class.
/// </summary>
/// <param name="itemMutableObject">
/// The agencyScheme.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
public GroupCore(IGroupMutableObject itemMutableObject, ISdmxStructure parent)
: base(itemMutableObject, parent)
{
this.dimensionRef = new List<string>();
if (itemMutableObject.AttachmentConstraintRef != null)
{
this.attachmentConstraintRef = new CrossReferenceImpl(this, itemMutableObject.AttachmentConstraintRef);
}
if (itemMutableObject.DimensionRef != null)
{
this.dimensionRef = new List<string>(itemMutableObject.DimensionRef);
}
this.ValidateGroupAttributes();
}
public DataSetReferenceCore(IDataSetReferenceMutableObject mutableObject, IMetadataTargetKeyValues parent)
: base(mutableObject, parent)
{
this._datasetId = mutableObject.DatasetId;
if (mutableObject.DataProviderReference != null)
{
this._dataProviderReference = new CrossReferenceImpl(this, mutableObject.DataProviderReference);
try
{
Validate();
}
catch (SdmxSemmanticException e)
{
throw new SdmxSemmanticException(e, ExceptionCode.FailValidation, this);
}
}
}
/// <summary>
/// Insert the specified <paramref name="maintainable"/> to the mapping store with <paramref name="state"/>
/// </summary>
/// <param name="state">
/// The MAPPING STORE connection and transaction state
/// </param>
/// <param name="maintainable">
/// The maintainable.
/// </param>
/// <returns>
/// The <see cref="ArtefactImportStatus"/>.
/// </returns>
public override ArtefactImportStatus Insert(DbTransactionState state, IHierarchicalCodelistObject maintainable)
{
var codelistCache = new StructureCache();
foreach (var codelistRef in maintainable.CodelistRef)
{
ICrossReference codelistReference = codelistRef.CodelistReference;
ItemSchemeFinalStatus itemSchemeFinalStatus = codelistCache.GetStructure(state, codelistReference);
var codelistMaintainableReference = codelistReference.MaintainableReference;
if (itemSchemeFinalStatus.FinalStatus.PrimaryKey <= 0)
{
string message = string.Format(
"HierarchicalCodeList {0} uses the CodeList:\r\n ID: {1}\r\n VERSION:{2}\r\n AGENCY: {3}\r\n which doesn't exist in the Mapping Store",
maintainable.Id,
codelistMaintainableReference.MaintainableId,
codelistMaintainableReference.Version,
codelistMaintainableReference.AgencyId);
return(new ArtefactImportStatus(-1, new ImportMessage(ImportMessageStatus.Error, codelistReference, message)));
}
if (!itemSchemeFinalStatus.FinalStatus.IsFinal)
{
string message = string.Format(
"HierarchicalCodeList {0} uses the CodeList:\r\n ID: {1}\r\n VERSION:{2}\r\n AGENCY: {3}\r\n which is not Final",
maintainable.Id,
codelistMaintainableReference.MaintainableId,
codelistMaintainableReference.Version,
codelistMaintainableReference.AgencyId);
return(new ArtefactImportStatus(-1, new ImportMessage(ImportMessageStatus.Error, codelistReference, message)));
}
}
_log.DebugFormat(CultureInfo.InvariantCulture, "Importing artefact {0}", maintainable.Urn);
var artefactStoredProcedure = _storedProcedures.InsertHcl;
var artefactStatus = this.InsertArtefactInternal(state, maintainable, artefactStoredProcedure);
foreach (KeyValuePair <long, IHierarchy> hierarchy in this.InsertHierarchies(state, maintainable.Hierarchies, artefactStatus.PrimaryKeyValue))
{
var levelIds = this.InsertLevels(state, hierarchy.Value.Level, hierarchy.Key);
this.InsertCodeReferences(state, hierarchy.Value.HierarchicalCodeObjects, hierarchy.Key, codelistCache, levelIds);
}
return(artefactStatus);
}
public Concept(IConceptObject concept)
{
this._id = concept.Id;
this._names = new List<TextTypeWrapper>();
this._descriptions = new List<TextTypeWrapper>();
foreach (var text in concept.Names)
this._names.Add(new TextTypeWrapper(text.Locale, text.Value));
foreach (var text in concept.Descriptions)
this._descriptions.Add(new TextTypeWrapper(text.Locale, text.Value));
this._coreRepresentation = concept.CoreRepresentation;
this._isoConceptReference = concept.IsoConceptReference;
this._parentAgency = concept.ParentAgency;
this._parentConcept = concept.ParentConcept;
this._uri = concept.Uri;
this._urn = concept.Urn;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2.1 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="RepresentationCore"/> class.
/// </summary>
/// <param name="conceptRepresentation">
/// The sdmxObject.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
public RepresentationCore(ConceptRepresentation conceptRepresentation, IIdentifiableObject parent)
: base(_localRepresentation, parent)
{
if (conceptRepresentation.TextFormat != null)
{
this.textFormat = new TextFormatObjectCore(conceptRepresentation.TextFormat, this);
}
if (conceptRepresentation.Enumeration != null)
{
this.representation = RefUtil.CreateReference(this, conceptRepresentation.Enumeration);
if (conceptRepresentation.EnumerationFormat != null)
{
this.textFormat = new TextFormatObjectCore(conceptRepresentation.EnumerationFormat, this);
}
}
this.Validate();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM MUTABLE OBJECTS //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
#region Constructors and Destructors
/// <summary>
/// Initializes a new instance of the <see cref="SchemeMapCore"/> class.
/// </summary>
/// <param name="itemMutableObject">
/// The sdmxObject.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
internal SchemeMapCore(ISchemeMapMutableObject itemMutableObject, IIdentifiableObject parent)
: base(itemMutableObject, parent)
{
if (itemMutableObject.SourceRef != null)
{
this.sourceRef = new CrossReferenceImpl(this, itemMutableObject.SourceRef);
}
if (itemMutableObject.TargetRef != null)
{
this.targetRef = new CrossReferenceImpl(this, itemMutableObject.TargetRef);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2.1 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="ConceptCore"/> class.
/// </summary>
/// <param name="parent">
/// The parent.
/// </param>
/// <param name="concept">
/// The sdmxObject.
/// </param>
public ConceptCore(IConceptSchemeObject parent, ConceptType concept)
: base(concept, SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Concept), parent)
{
if (concept.CoreRepresentation != null)
{
this.coreRepresentation = new RepresentationCore(concept.CoreRepresentation, this);
}
if (concept.ISOConceptReference != null)
{
this.isoConceptReference = new CrossReferenceImpl(
this,
concept.ISOConceptReference.ConceptAgency,
concept.ISOConceptReference.ConceptSchemeID,
null,
SdmxStructureEnumType.Concept,
concept.ISOConceptReference.ConceptID);
}
var localItemReferenceType = concept.GetTypedParent<LocalConceptReferenceType>();
if (localItemReferenceType != null)
{
if (ObjectUtil.ValidCollection(localItemReferenceType.URN))
{
IStructureReference structureReference = new StructureReferenceImpl(localItemReferenceType.URN[0]);
this.parentConcept = structureReference.ChildReference.Id;
this.parentAgency = structureReference.MaintainableReference.AgencyId;
}
else
{
this.parentConcept = localItemReferenceType.GetTypedRef<LocalConceptRefType>().id;
this.parentAgency = this.MaintainableParent.AgencyId;
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V1 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="ComponentCore"/> class.
/// </summary>
/// <param name="createdFrom">
/// The created from.
/// </param>
/// <param name="structureType">
/// The structure type.
/// </param>
/// <param name="annotationType">
/// The annotation type.
/// </param>
/// <param name="codelistId">
/// The codelist id.
/// </param>
/// <param name="conceptId">
/// The concept id.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
protected internal ComponentCore(
IXmlSerializable createdFrom,
SdmxStructureType structureType,
Org.Sdmx.Resources.SdmxMl.Schemas.V10.common.AnnotationsType annotationType,
string codelistId,
string conceptId,
ISdmxStructure parent)
: base(createdFrom, structureType, conceptId, null, annotationType, parent)
{
if (!string.IsNullOrWhiteSpace(codelistId))
{
this.LocalRepresentation = new RepresentationCore(codelistId, this);
}
this._conceptRef = new CrossReferenceImpl(
this,
this.MaintainableParent.AgencyId,
ConceptSchemeObject.DefaultSchemeVersion,
ConceptSchemeObject.DefaultSchemeVersion,
SdmxStructureEnumType.Concept,
conceptId);
this.ValidateComponentAttributes();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="ComponentCore"/> class.
/// </summary>
/// <param name="createdFrom">
/// The created from.
/// </param>
/// <param name="structureType">
/// The structure type.
/// </param>
/// <param name="annotationType">
/// The annotation type.
/// </param>
/// <param name="textFormat">
/// The text format.
/// </param>
/// <param name="codelistAgency">
/// The codelist agency.
/// </param>
/// <param name="codelistId">
/// The codelist id.
/// </param>
/// <param name="codelistVersion">
/// The codelist version.
/// </param>
/// <param name="conceptSchemeAgency">
/// The concept scheme agency.
/// </param>
/// <param name="conceptSchemeId">
/// The concept scheme id.
/// </param>
/// <param name="conceptSchemeVersion">
/// The concept scheme version.
/// </param>
/// <param name="conceptAgency">
/// The concept agency.
/// </param>
/// <param name="conceptId">
/// The concept id.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
protected internal ComponentCore(
IXmlSerializable createdFrom,
SdmxStructureType structureType,
AnnotationsType annotationType,
TextFormatType textFormat,
string codelistAgency,
string codelistId,
string codelistVersion,
string conceptSchemeAgency,
string conceptSchemeId,
string conceptSchemeVersion,
string conceptAgency,
string conceptId,
IIdentifiableObject parent)
: base(createdFrom, structureType, conceptId, null, annotationType, parent)
{
if (string.IsNullOrWhiteSpace(conceptAgency))
{
conceptAgency = this.MaintainableParent.AgencyId;
}
if (textFormat != null || ObjectUtil.ValidOneString(codelistAgency, codelistId, codelistVersion))
{
if (ObjectUtil.ValidOneString(codelistAgency, codelistId, codelistVersion))
{
if (string.IsNullOrWhiteSpace(codelistAgency))
{
codelistAgency = this.MaintainableParent.AgencyId;
}
}
this.LocalRepresentation = new RepresentationCore(
textFormat, codelistAgency, codelistId, codelistVersion, this);
}
this._conceptRef = ConceptRefUtil.BuildConceptRef(
this, conceptSchemeAgency, conceptSchemeId, conceptSchemeVersion, conceptAgency, conceptId);
this.ValidateComponentAttributes();
}
/// <summary>
/// Adds code references.
/// </summary>
/// <param name="constraintBean">
/// The constraint object.
/// </param>
/// <param name="returnReferences">
/// The returned references.
/// </param>
/// <param name="codelistRef">
/// The code list reference object.
/// </param>
/// <param name="codeIds">
/// The code ids.
/// </param>
private void AddCodeReferences(IContentConstraintObject constraintBean, ISet<ICrossReference> returnReferences, ICrossReference codelistRef, ICollection<string> codeIds)
{
string agencyId = codelistRef.AgencyId;
string codelistId = codelistRef.MaintainableId;
string version = codelistRef.Version;
foreach (string codeId in codeIds)
{
ICrossReference codeRef = new CrossReferenceImpl(constraintBean, agencyId, codelistId, version, SdmxStructureEnumType.Code, codeId);
returnReferences.Add(codeRef);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V1 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="RepresentationCore"/> class.
/// </summary>
/// <param name="codelistId">
/// The codelist id.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
protected internal RepresentationCore(string codelistId, IIdentifiableObject parent)
: base(_localRepresentation, parent)
{
if (!string.IsNullOrWhiteSpace(codelistId))
{
this.representation = new CrossReferenceImpl(
this,
parent.MaintainableParent.AgencyId,
codelistId,
null,
SdmxStructureType.GetFromEnum(SdmxStructureEnumType.CodeList));
}
this.Validate();
}
/// <summary>
/// Initializes a new instance of the <see cref="CategoryMock"/> class.
/// </summary>
/// <param name="crossReference">
/// The cross reference.
/// </param>
public CategoryMock(ICrossReference crossReference)
{
this._crossReference = crossReference;
this._categorisation = this._crossReference.ReferencedFrom as ICategorisationObject;
}
/// <summary>
/// Initializes a new instance of the <see cref="CrossReferenceException"/> class.
/// </summary>
/// <param name="info">
/// The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.
/// </param>
/// <param name="context">
/// The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.
/// </param>
/// <exception cref="T:System.ArgumentNullException">
/// The <paramref name="info"/> parameter is null.
/// </exception>
/// <exception cref="T:System.Runtime.Serialization.SerializationException">
/// The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).
/// </exception>
protected CrossReferenceException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
this._crossReference = (ICrossReference)info.GetValue("_crossReference", typeof(ICrossReference));
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2.1 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="InputOutputCore"/> class.
/// </summary>
/// <param name="parent">
/// The parent.
/// </param>
/// <param name="xmlType">
/// The xml type.
/// </param>
public InputOutputCore(IIdentifiableObject parent, InputOutputType xmlType)
: base(xmlType, SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Computation), parent)
{
this.localId = xmlType.localID;
if (xmlType.ObjectReference != null)
{
this.structureReference = RefUtil.CreateReference(this, xmlType.ObjectReference);
}
this.Validate();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2.1 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
#region Constructors and Destructors
/// <summary>
/// Initializes a new instance of the <see cref="ReferenceValueObjectCore" /> class.
/// </summary>
/// <param name="parent"> The parent. </param>
/// <param name="type"> The type. </param>
public ReferenceValueObjectCore(ITarget parent, ReferenceValueType type)
: base(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.MetadataReferenceValue), parent)
{
this.dataKeys = new List<IDataKey>();
this.id = type.id;
if (type.ConstraintContentReference != null)
{
this.constraintReference = RefUtil.CreateReference(this, type.ConstraintContentReference);
}
if (type.ObjectReference != null)
{
this.identifiableReference = RefUtil.CreateReference(this, type.ObjectReference);
}
if (type.DataSetReference != null)
{
this.datasetId = type.DataSetReference.ID;
this.identifiableReference = RefUtil.CreateReference(this, type.DataSetReference.DataProvider);
}
if (type.DataKey != null)
{
foreach (var cvst in type.DataKey.GetTypedKeyValue<DataKeyValueType>())
{
this.dataKeys.Add(new DataKeyObjectCore(this, cvst));
}
}
if (type.ReportPeriod != null)
{
reportPeriod = new SdmxDateCore(type.ReportPeriod.ToString());
}
this.Validate();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2.1 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="GroupCore"/> class.
/// </summary>
/// <param name="group">
/// The group.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
public GroupCore(GroupType group, ISdmxStructure parent)
: base(group, SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Group), parent)
{
this.dimensionRef = new List<string>();
if (group.AttachmentConstraint != null)
{
this.attachmentConstraintRef = RefUtil.CreateReference(this, group.AttachmentConstraint);
}
if (group.GroupDimension != null)
{
this.dimensionRef = new List<string>();
foreach (GroupDimension each in group.GroupDimension)
{
this.dimensionRef.Add(RefUtil.CreateLocalIdReference(each.DimensionReference));
}
}
this.ValidateGroupAttributes();
}
/// <summary>
/// Initializes a new instance of the <see cref="RepresentationCore"/> class.
/// </summary>
/// <param name="representationType">
/// The sdmxObject.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
public RepresentationCore(RepresentationType representationType, IIdentifiableObject parent)
: base(_localRepresentation, parent)
{
if (representationType.TextFormat != null)
{
this.textFormat = new TextFormatObjectCore(representationType.TextFormat, this);
}
ItemSchemeReferenceBaseType reference;
if (representationType.CodelistEnumeration != null)
{
reference = representationType.CodelistEnumeration;
}
else
{
reference = representationType.ConceptSchemeEnumeration;
}
if (reference != null)
{
this.representation = RefUtil.CreateReference(this, reference);
if (representationType.EnumerationFormat != null)
{
this.textFormat = new TextFormatObjectCore(representationType.EnumerationFormat, this);
}
}
this.Validate();
}
/// <summary>
/// Populate the <paramref name="metadataflowRef"/> from <paramref name="crossReference"/>
/// </summary>
/// <param name="crossReference">
/// The cross reference.
/// </param>
/// <param name="metadataflowRef">
/// The metadataflow reference.
/// </param>
internal void PopulateMetadataflowRef(ICrossReference crossReference, MetadataflowRefType metadataflowRef)
{
IMaintainableRefObject maintRef = crossReference.MaintainableReference;
{
metadataflowRef.URN = crossReference.TargetUrn;
}
string str1 = maintRef.AgencyId;
if (!string.IsNullOrWhiteSpace(str1))
{
metadataflowRef.AgencyID = maintRef.AgencyId;
}
string str2 = maintRef.MaintainableId;
if (!string.IsNullOrWhiteSpace(str2))
{
metadataflowRef.MetadataflowID = maintRef.MaintainableId;
}
string str3 = maintRef.Version;
if (!string.IsNullOrWhiteSpace(str3))
{
metadataflowRef.Version = maintRef.Version;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="RepresentationCore"/> class.
/// </summary>
/// <param name="textFormat0">
/// The text format 0.
/// </param>
/// <param name="codelistAgency">
/// The codelist agency.
/// </param>
/// <param name="codelistId">
/// The codelist id.
/// </param>
/// <param name="codelistVersion">
/// The codelist version.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
public RepresentationCore(
TextFormatType textFormat0,
string codelistAgency,
string codelistId,
string codelistVersion,
IIdentifiableObject parent)
: base(_localRepresentation, parent)
{
if (textFormat0 != null)
{
this.textFormat = new TextFormatObjectCore(textFormat0, this);
}
if (ObjectUtil.ValidOneString(codelistAgency, codelistId, codelistVersion))
{
if (string.IsNullOrWhiteSpace(codelistAgency))
{
codelistAgency = this.MaintainableParent.AgencyId;
}
SdmxStructureType structureType = SdmxStructureType.GetFromEnum(SdmxStructureEnumType.CodeList);
if (parent.MaintainableParent is ICrossSectionalDataStructureObject)
{
if (parent is IDimension)
{
if (((IDimension)parent).MeasureDimension)
{
structureType = SdmxStructureType.GetFromEnum(SdmxStructureEnumType.ConceptScheme);
}
}
}
this.representation = new CrossReferenceImpl(
this, codelistAgency, codelistId, codelistVersion, structureType);
}
this.Validate();
}
/// <summary>
/// Initializes a new instance of the <see cref="DataAndMetadataSetReferenceCore"/> class.
/// </summary>
/// <param name="crossReference">
/// The cross reference.
/// </param>
/// <param name="id1">
/// The id 1.
/// </param>
/// <param name="isIsDataSetReference2">
/// The is is data set reference 2.
/// </param>
/// <exception cref="SdmxSemmanticException">
/// Throws Validate exception.
/// </exception>
public DataAndMetadataSetReferenceCore(
ICrossReference crossReference, string id1, bool isIsDataSetReference2)
{
this._icrossReference = crossReference;
this._id = id1;
this._isIsDataSetReference = isIsDataSetReference2;
if (crossReference == null)
{
throw new SdmxSemmanticException(
"DataAndMetadataSetReferenceCore expects IcrossReference (null was provided)");
}
if (id1 == null)
{
throw new SdmxSemmanticException("DataAndMetadataSetReferenceCore expects id (null was provided)");
}
}
/// <summary>
/// Populate the <paramref name="dataProviderRef"/> from <paramref name="crossReference"/>
/// </summary>
/// <param name="crossReference">
/// The cross reference.
/// </param>
/// <param name="dataProviderRef">
/// The data Provider reference.
/// </param>
internal void PopulateDataproviderRef(ICrossReference crossReference, DataProviderRefType dataProviderRef)
{
IMaintainableRefObject maintRef = crossReference.MaintainableReference;
{
dataProviderRef.URN = crossReference.TargetUrn;
}
string str1 = maintRef.AgencyId;
if (!string.IsNullOrWhiteSpace(str1))
{
dataProviderRef.OrganisationSchemeAgencyID = maintRef.AgencyId;
}
string str2 = maintRef.MaintainableId;
if (!string.IsNullOrWhiteSpace(str2))
{
dataProviderRef.OrganisationSchemeID = maintRef.MaintainableId;
}
string str3 = maintRef.Version;
if (!string.IsNullOrWhiteSpace(str3))
{
dataProviderRef.Version = maintRef.Version;
}
string str4 = crossReference.ChildReference.Id;
if (!string.IsNullOrWhiteSpace(str4))
{
dataProviderRef.DataProviderID = crossReference.ChildReference.Id;
}
}
/// <summary>
/// Adds components to the component map.
/// </summary>
/// <param name="retrievalManager">
/// The retrieval manager
/// </param>
/// <param name="crossRef">
/// The cross reference object
/// </param>
/// <param name="componentMap">
/// The components map
/// </param>
private void AddComponenents(ISdmxObjectRetrievalManager retrievalManager, ICrossReference crossRef, IDictionary<String, IComponent> componentMap)
{
switch (crossRef.TargetReference.EnumType)
{
case SdmxStructureEnumType.ProvisionAgreement:
IProvisionAgreementObject prov = retrievalManager.GetMaintainableObject<IProvisionAgreementObject>(crossRef);
if (prov == null)
{
prov = _beanRetrievalManager.GetMaintainableObject<IProvisionAgreementObject>(crossRef);
if (prov == null)
throw new CrossReferenceException(crossRef);
}
crossRef = prov.StructureUseage; //Drop through to the next switch statement
break;
case SdmxStructureEnumType.Dataflow:
IDataflowObject flow = retrievalManager.GetMaintainableObject<IDataflowObject>(crossRef);
if (flow == null)
{
flow = _beanRetrievalManager.GetMaintainableObject<IDataflowObject>(crossRef);
if (flow == null)
throw new CrossReferenceException(crossRef);
}
crossRef = flow.DataStructureRef; //Drop through to the next switch statement
break;
case SdmxStructureEnumType.Dsd:
IDataStructureObject dsd = retrievalManager.GetMaintainableObject<IDataStructureObject>(crossRef);
if (dsd == null)
{
dsd = _beanRetrievalManager.GetMaintainableObject<IDataStructureObject>(crossRef);
if (dsd == null)
throw new CrossReferenceException(crossRef);
}
foreach (IComponent currentComponent in dsd.Components)
componentMap.Add(currentComponent.Id, currentComponent);
break;
}
}
/// <summary>
/// Resolves an identifiable reference
/// </summary>
/// <param name="crossReference"> Cross-reference object
/// </param>
/// <returns>
/// SdmxException Not Implemented
/// </returns>
public IIdentifiableObject GetIdentifiableObject(ICrossReference crossReference)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.GetMaintainableFromSdmxObject, null);
}
/// <summary>
/// Generate a key using the following format AgencyID+ID+Version
/// </summary>
/// <param name="reference">
/// The artefact reference to generate the key for
/// </param>
/// <returns>
/// The key
/// </returns>
public static string MakeKey(ICrossReference reference)
{
return(MakeKey(reference.MaintainableReference.MaintainableId, reference.MaintainableReference.AgencyId, reference.MaintainableReference.Version));
}
/// <summary>
/// Gets the reference from identifier.
/// </summary>
/// <param name="crossReference">The cross reference.</param>
/// <returns>A string containing the URN or the <see cref="ISdmxObject"/> it referenced</returns>
private static string GetReferenceFromIdentifier(ICrossReference crossReference)
{
if (crossReference == null)
{
throw new ArgumentNullException("crossReference");
}
var parentIdentifiable = crossReference.ReferencedFrom.GetParent<IIdentifiableObject>(true);
if (parentIdentifiable != null)
{
return parentIdentifiable.Urn.ToString();
}
return crossReference.ReferencedFrom.ToString();
}
/// <summary>
/// Initializes a new instance of the <see cref="ComponentCore"/> class.
/// </summary>
/// <param name="createdFrom">
/// The created from.
/// </param>
/// <param name="structureType">
/// The structure type.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
protected internal ComponentCore(
ComponentType createdFrom, SdmxStructureType structureType, IIdentifiableObject parent)
: base(createdFrom, structureType, parent)
{
var simpleDataStructureRepresentationType = createdFrom.GetTypedLocalRepresentation<SimpleDataStructureRepresentationType>();
if (simpleDataStructureRepresentationType != null)
{
this.LocalRepresentation = new RepresentationCore(simpleDataStructureRepresentationType, this);
}
if (createdFrom.ConceptIdentity != null)
{
this._conceptRef = RefUtil.CreateReference(this, createdFrom.ConceptIdentity);
}
// FUNC 2.1 put in Concept Identifity = conceptRef
this.ValidateComponentAttributes();
}
