/// <summary>
        /// Adds new data structure ref submission result.
        /// </summary>
        /// <param name="returnType">
        /// The return type.
        /// </param>
        /// <param name="structureReference">
        /// The structure reference
        /// </param>
        /// <param name="exception">
        /// The exception.
        /// </param>
        private static void AddNewDataStructureRefSubmissionResult(
            SubmitStructureResponseType returnType, IStructureReference structureReference, Exception exception)
        {
            SubmissionResultType result = GetNewSubmissionResultType(returnType, exception);
            var submittedStructure = new SubmittedStructureType();
            result.SubmittedStructure = submittedStructure;
            var refType = new KeyFamilyRefType();
            submittedStructure.KeyFamilyRef = refType;

            IMaintainableRefObject maintainableReference = structureReference.MaintainableReference;
            refType.AgencyID = maintainableReference.AgencyId;
            refType.KeyFamilyID = maintainableReference.MaintainableId;
            if (ObjectUtil.ValidString(structureReference.MaintainableUrn))
            {
                refType.URN = structureReference.MaintainableUrn;
            }

            string value = maintainableReference.Version;
            if (!string.IsNullOrWhiteSpace(value))
            {
                refType.Version = maintainableReference.Version;
            }
        }
        /// <summary>
        /// Sets the attributes of <paramref name="refType"/>
        /// </summary>
        /// <param name="refType">
        /// The reference type
        /// </param>
        /// <param name="crossReference">
        /// The cross-reference
        /// </param>
        private static void SetDataStructureRefAttributes(KeyFamilyRefType refType, IStructureReference crossReference)
        {
            IMaintainableRefObject maintainableReference = crossReference.MaintainableReference;
            string str0 = maintainableReference.AgencyId;
            if (!string.IsNullOrWhiteSpace(str0))
            {
                refType.KeyFamilyAgencyID = maintainableReference.AgencyId;
            }

            string str1 = maintainableReference.MaintainableId;
            if (!string.IsNullOrWhiteSpace(str1))
            {
                refType.KeyFamilyID = maintainableReference.MaintainableId;
            }

            refType.URN = crossReference.TargetUrn;

            string str3 = maintainableReference.Version;
            if (!string.IsNullOrWhiteSpace(str3))
            {
                refType.Version = maintainableReference.Version;
            }
        }
        /// <summary>
        /// The process structure map.
        /// </summary>
        /// <param name="structureSetType">
        /// The structure set type.
        /// </param>
        /// <param name="buildFrom">
        /// The build from.
        /// </param>
        private void ProcessStructureMap(StructureSetType structureSetType, IStructureMapObject buildFrom)
        {
            var structureMapType = new StructureMapType();
            structureSetType.StructureMap = structureMapType;

            structureMapType.isExtension = buildFrom.Extension;

            string str0 = buildFrom.Id;
            if (!string.IsNullOrWhiteSpace(str0))
            {
                structureMapType.id = buildFrom.Id;
            }

            IList<ITextTypeWrapper> names = buildFrom.Names;
            if (ObjectUtil.ValidCollection(names))
            {
                structureMapType.Name = this.GetTextType(names);
            }

            IList<ITextTypeWrapper> descriptions = buildFrom.Descriptions;
            if (ObjectUtil.ValidCollection(descriptions))
            {
                structureMapType.Description = this.GetTextType(descriptions);
            }

            if (buildFrom.SourceRef != null)
            {
                if (buildFrom.SourceRef.TargetReference.EnumType == SdmxStructureEnumType.Dsd)
                {
                    var keyFamilyRef = new KeyFamilyRefType();
                    structureMapType.KeyFamilyRef = keyFamilyRef;
                    SetDataStructureRefAttributes(keyFamilyRef, buildFrom.SourceRef);
                }
                else if (buildFrom.SourceRef.TargetReference.EnumType == SdmxStructureEnumType.Msd)
                {
                    var refType = new MetadataStructureRefType();
                    structureMapType.MetadataStructureRef = refType;
                    SetMetadataStructureRefAttributes(refType, buildFrom.SourceRef);
                }
            }

            if (buildFrom.TargetRef != null)
            {
                if (buildFrom.TargetRef.TargetReference.EnumType == SdmxStructureEnumType.Dsd)
                {
                    var keyFamilyRef = new KeyFamilyRefType();
                    structureMapType.TargetKeyFamilyRef = keyFamilyRef;
                    SetDataStructureRefAttributes(keyFamilyRef, buildFrom.TargetRef);
                }
                else if (buildFrom.TargetRef.TargetReference.EnumType == SdmxStructureEnumType.Msd)
                {
                    var refType1 = new MetadataStructureRefType();
                    structureMapType.TargetMetadataStructureRef = refType1;
                    SetMetadataStructureRefAttributes(refType1, buildFrom.TargetRef);
                }
            }

            IList<IComponentMapObject> componentMapObjects = buildFrom.Components;
            if (ObjectUtil.ValidCollection(componentMapObjects))
            {
                /* foreach */
                foreach (IComponentMapObject componentMapBean in componentMapObjects)
                {
                    var componentMapType = new ComponentMapType();
                    structureMapType.ComponentMap.Add(componentMapType);
                    this.ProcessComponent(componentMapType, componentMapBean);
                }
            }

            if (this.HasAnnotations(buildFrom))
            {
                structureMapType.Annotations = this.GetAnnotationsType(buildFrom);
            }
        }
        /// <summary>
        /// Process related structures.
        /// </summary>
        /// <param name="structureSetType">
        /// The structure set type.
        /// </param>
        /// <param name="buildFrom">
        /// The build from.
        /// </param>
        private static void ProcessRelatedStructures(StructureSetType structureSetType, IStructureSetObject buildFrom)
        {
            if (buildFrom.RelatedStructures != null)
            {
                var relatedStructuresType = new RelatedStructuresType();
                structureSetType.RelatedStructures = relatedStructuresType;
                IRelatedStructures relatedStructures = buildFrom.RelatedStructures;

                // KEY FAMILY REF
                foreach (ICrossReference xref in relatedStructures.DataStructureRef)
                {
                    var keyFamilyRefType = new KeyFamilyRefType();
                    relatedStructuresType.KeyFamilyRef.Add(keyFamilyRefType);
                    SetDataStructureRefAttributes(keyFamilyRefType, xref);
                }

                // METADATA STRUCTURE REF
                foreach (ICrossReference ref0 in relatedStructures.MetadataStructureRef)
                {
                    var refType = new MetadataStructureRefType();
                    relatedStructuresType.MetadataStructureRef.Add(refType);
                    SetMetadataStructureRefAttributes(refType, ref0);
                }

                // CONCEPT SCHEME REF
                foreach (ICrossReference ref1 in relatedStructures.ConceptSchemeRef)
                {
                    var refType2 = new ConceptSchemeRefType();
                    relatedStructuresType.ConceptSchemeRef.Add(refType2);
                    SetConceptSchemeRefAttributes(refType2, ref1);
                }

                // CATEGORY SCHEME REF
                foreach (ICrossReference ref3 in relatedStructures.CategorySchemeRef)
                {
                    var refType4 = new CategorySchemeRefType();
                    relatedStructuresType.CategorySchemeRef.Add(refType4);
                    SetCategorySchemeRefAttributes(refType4, ref3);
                }

                // ORGANISATION SCHEME REF
                foreach (ICrossReference ref5 in relatedStructures.OrgSchemeRef)
                {
                    var refType6 = new OrganisationSchemeRefType();
                    relatedStructuresType.OrganisationSchemeRef.Add(refType6);
                    SetOrganisationSchemeRefAttributes(refType6, ref5);
                }

                // HCL REF
                foreach (ICrossReference ref7 in relatedStructures.HierCodelistRef)
                {
                    var refType8 = new HierarchicalCodelistRefType();
                    relatedStructuresType.HierarchicalCodelistRef.Add(refType8);
                    SetHclRefAttributes(refType8, ref7);
                }
            }
        }