/// <summary>
 /// Initializes a new instance of the <see cref="AgencyMetadataImpl"/> class.
 /// </summary>
 /// <param name="agencyId">
 /// The agency id.
 /// </param>
 /// <param name="objects">
 /// The objects.
 /// </param>
 public AgencyMetadataImpl(string agencyId, ISdmxObjects objects)
 {
     this._structureMap = new Dictionary<SdmxStructureEnumType, int>();
     this._agencyId = agencyId;
     this._structureMap.Add(SdmxStructureEnumType.AgencyScheme, objects.GetAgenciesScheme(agencyId) == null ? 0 : 1);
     this._structureMap.Add(
         SdmxStructureEnumType.AttachmentConstraint, objects.GetAttachmentConstraints(agencyId).Count);
     this._structureMap.Add(
         SdmxStructureEnumType.ContentConstraint, objects.GetContentConstraintObjects(agencyId).Count);
     this._structureMap.Add(
         SdmxStructureEnumType.DataProviderScheme, objects.GetDataProviderScheme(agencyId) == null ? 0 : 1);
     this._structureMap.Add(
         SdmxStructureEnumType.DataConsumerScheme, objects.GetDataConsumerScheme(agencyId) == null ? 0 : 1);
     this._structureMap.Add(
         SdmxStructureEnumType.OrganisationUnitScheme, objects.GetOrganisationUnitSchemes(agencyId).Count);
     this._structureMap.Add(SdmxStructureEnumType.Categorisation, objects.GetCategorisations(agencyId).Count);
     this._structureMap.Add(SdmxStructureEnumType.Dataflow, objects.GetDataflows(agencyId).Count);
     this._structureMap.Add(SdmxStructureEnumType.MetadataFlow, objects.GetMetadataflows(agencyId).Count);
     this._structureMap.Add(SdmxStructureEnumType.CategoryScheme, objects.GetCategorySchemes(agencyId).Count);
     this._structureMap.Add(SdmxStructureEnumType.ConceptScheme, objects.GetConceptSchemes(agencyId).Count);
     this._structureMap.Add(SdmxStructureEnumType.CodeList, objects.GetCodelists(agencyId).Count);
     this._structureMap.Add(
         SdmxStructureEnumType.HierarchicalCodelist, objects.GetHierarchicalCodelists(agencyId).Count);
     this._structureMap.Add(SdmxStructureEnumType.Msd, objects.GetMetadataStructures(agencyId).Count);
     this._structureMap.Add(SdmxStructureEnumType.Dsd, objects.GetDataStructures(agencyId).Count);
     this._structureMap.Add(SdmxStructureEnumType.Process, objects.GetProcesses(agencyId).Count);
     this._structureMap.Add(
         SdmxStructureEnumType.ReportingTaxonomy, objects.GetReportingTaxonomys(agencyId).Count);
     this._structureMap.Add(SdmxStructureEnumType.StructureSet, objects.GetStructureSets(agencyId).Count);
     this._structureMap.Add(
         SdmxStructureEnumType.ProvisionAgreement, objects.GetProvisionAgreements(agencyId).Count);
 }

        /// <summary>
        /// The build registry interface document.
        /// </summary>
        /// <param name="buildFrom">
        /// The build from.
        /// </param>
        /// <param name="action">
        /// The action.
        /// </param>
        /// <returns>
        /// The <see cref="RegistryInterface"/>.
        /// </returns>
        public RegistryInterface BuildRegistryInterfaceDocument(ISdmxObjects buildFrom, DatasetAction action)
        {
            var rid = new RegistryInterface();
            RegistryInterfaceType rit = rid.Content;
            V21Helper.Header = rit;
            var structureRequestType = new SubmitStructureRequestType();
            rit.SubmitStructureRequest = structureRequestType;
            switch (action.EnumType)
            {
                case DatasetActionEnumType.Append:
                    structureRequestType.action = ActionTypeConstants.Append;
                    break;
                case DatasetActionEnumType.Replace:
                    structureRequestType.action = ActionTypeConstants.Replace;
                    break;
                case DatasetActionEnumType.Delete:
                    structureRequestType.action = ActionTypeConstants.Delete;
                    break;
                case DatasetActionEnumType.Information:
                    structureRequestType.action = ActionTypeConstants.Information;
                    break;
            }

            var structures = new Structures();
            structureRequestType.Structures = structures;
            this._structureXmlBuilder.PopulateStructureType(buildFrom, structures.Content);

            return rid;
        }

        /// <summary>
        /// Sets the header.
        /// </summary>
        /// <param name="header">
        /// The header.
        /// </param>
        /// <param name="sdmxObjects">
        /// The beans.
        /// </param>
        public static void SetHeader(HeaderType header, ISdmxObjects sdmxObjects)
        {
            header.ID = "IDREF" + refNumber;
            refNumber++;
            header.Test = false;
            header.Prepared = DateTime.Now;
            var sender = new PartyType();
            header.Sender.Add(sender);

            string senderId;
            if (sdmxObjects != null && sdmxObjects.Header != null && sdmxObjects.Header.Sender != null)
            {
                // Get header information from the supplied beans
                senderId = sdmxObjects.Header.Sender.Id;
            }
            else
            {
                // Get header info from HeaderHelper
                senderId = HeaderHelper.Instance.SenderId;
            }

            sender.id = senderId;

            var receiver = new PartyType();
            header.Receiver.Add(receiver);
            receiver.id = HeaderHelper.Instance.ReceiverId;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="DataSetModelStore"/> class. 
 /// Initialize a new instance of the <see cref="DataSetModelStore"/>
 /// </summary>
 /// <param name="structure">
 /// The SDMX structure file
 /// </param>
 /// <param name="store">
 /// The <see cref="IDataSetStore"/>
 /// </param>
 public DataSetModelStore(ISdmxObjects structure, IDataSetStore store)
     : base(structure, store)
 {
     if (store == null)
     {
         throw new ArgumentNullException("store");
     }
 }

        public void WriteStructures(ISdmxObjects sdmxObjects)
        {
            foreach (var maintainableObject in sdmxObjects.GetAllMaintainables())
            {
                PrintMaintainable(maintainableObject);
            }

            Close();
        }

        /// <summary>
        /// Adds a bean to the container as long as the urn of the bean to add is not contained in the set of URNs.
        ///     <p/>
        ///     If successfully added, will add the bean urn to the set of urns
        /// </summary>
        /// <param name="beans">
        /// container to add to
        /// </param>
        /// <param name="urns">
        /// to exclude
        /// </param>
        /// <param name="bean">
        /// to add to the beans container
        /// </param>
        protected internal void AddIfNotDuplicateURN(ISdmxObjects beans, ISet<Uri> urns, IIdentifiableObject bean)
        {
            if (!urns.Add(bean.Urn))
            {
                throw new SdmxSemmanticException(ExceptionCode.DuplicateUrn, bean.Urn);
            }

            beans.AddIdentifiable(bean);
        }

        /// <summary>
        /// The write structures.
        /// </summary>
        /// <param name="beans">
        /// The beans.
        /// </param>
        /// <exception cref="NotImplementedException">
        /// SDMX EDI for structures is not implemented in this implementation.
        /// </exception>
        public virtual void WriteStructures(ISdmxObjects beans)
        {
            throw new NotImplementedException("SDMX EDI for structures is not implemented in this implementation.");

            ////if (editParseManager == null) {
            ////    throw new Exception(
            ////            "Required dependancy 'structureReaderEngine' is null, StructureWriterEngineEdi is @Configurable and requires '<context:spring-configured />' to be set");
            ////}
            ////editParseManager.WriteToEDI(beans, xout);
        }

 /// <summary>
 /// </summary>
 /// <param name="structures"> The structures</param>
 /// <param name="resolveAgencies"> Flag indicating resolve agencies .</param>
 /// <param name="resolutionDepth"> The resolution depth. </param>
 /// <param name="retrievalManager"> The retrieval manager </param>
 /// <returns> The references </returns>
 public IDictionary<IIdentifiableObject, ISet<IIdentifiableObject>> ResolveReferences(
     ISdmxObjects structures,
     bool resolveAgencies,
     int resolutionDepth,
     IIdentifiableRetrievalManager retrievalManager)
 {
     ICrossReferenceResolverEngine crossReferenceResolver = new CrossReferenceResolverEngineCore();
     return crossReferenceResolver.ResolveReferences(
         structures, resolveAgencies, resolutionDepth, retrievalManager);
 }

        /// <summary>
        /// The build success response.
        /// </summary>
        /// <param name="beans">
        /// The beans.
        /// </param>
        /// <returns>
        /// The <see cref="RegistryInterface"/>.
        /// </returns>
        public RegistryInterface BuildSuccessResponse(ISdmxObjects beans)
        {
            var responseType = new RegistryInterface();
            RegistryInterfaceType regInterface = responseType.Content;
            regInterface.Header = this._headerXmlsBuilder.Build(beans.Header);
            var returnType = new SubmitStructureResponseType();
            regInterface.SubmitStructureResponse = returnType;


            this.ProcessMaintainables(returnType, beans.GetAllMaintainables());
            return responseType;
        }

        public DataRender(IDataSetStore store, List<DataCriteria> Criterias, LayoutObj layObj, ISdmxObjects structure, ComponentCodeDescriptionDictionary codemap, bool useAttr, CultureInfo cFrom, CultureInfo cTo)
        {
            this.store = store;
            this.Criterias = Criterias;
            this.layObj = layObj;
            this.Structure = structure;
            this.codemap = codemap;
            this._useAttr=useAttr;

            this.cFrom=cFrom;
            this.cTo=cTo;
        }

        /// <summary>
        /// Builds Mutable beans from a collection of beans
        /// </summary>
        /// <param name="buildFrom">
        /// beans to build from
        /// </param>
        /// <returns>
        /// Mutable bean copies
        /// </returns>
        /// <exception cref="BuilderException">
        /// - If anything goes wrong during the build process
        /// </exception>
        public virtual IMutableObjects Build(ISdmxObjects buildFrom)
        {
            IMutableObjects mutableBeans = new MutableObjectsImpl();

            /* foreach */
            foreach (IMaintainableObject currentMaintainable in buildFrom.GetAllMaintainables())
            {
                mutableBeans.AddIdentifiable(currentMaintainable.MutableInstance);
            }

            return mutableBeans;
        }

        public List<AgencyScheme> GetAgencySchemeList(ISdmxObjects sdmxObjects, string localization)
        {
            if (sdmxObjects == null || sdmxObjects.AgenciesSchemes == null)
                return null;

            List<AgencyScheme> lAS = new List<AgencyScheme>();

            foreach (IAgencyScheme agency in sdmxObjects.AgenciesSchemes)
            {
                lAS.Add(new AgencyScheme(_localizedUtils.GetNameableName(agency), agency.Id, agency.AgencyId, agency.Version, agency.IsFinal.IsTrue));
            }

            return lAS;
        }

        public void SaveSDMXFile(ISdmxObjects sdmxObjects, StructureOutputFormatEnumType version, string outputFileName)
        {

            StructureWriterManager swm = new StructureWriterManager();

            StructureOutputFormat soFormat = StructureOutputFormat.GetFromEnum(version);
            IStructureFormat outputFormat = new SdmxStructureFormat(soFormat);

            MemoryStream memoryStream = new MemoryStream();

            swm.WriteStructures(sdmxObjects, outputFormat, memoryStream);


            byte[] bytesInStream = memoryStream.ToArray();
            memoryStream.Close();

            SendAttachment(bytesInStream, outputFileName + ".xml");
        }

        /// <summary>
        /// The set header.
        /// </summary>
        /// <param name="header">
        /// The header.
        /// </param>
        /// <param name="sdmxObjects">
        /// The sdmxObjects.
        /// </param>
        public static void SetHeader(HeaderType header, ISdmxObjects sdmxObjects)
        {
            header.ID = "IDREF" + referenceNo;
            referenceNo++;
            header.Test = false;
            header.Prepared = DateTime.Now;

            string senderId;
            if (sdmxObjects != null && sdmxObjects.Header != null && sdmxObjects.Header.Sender != null)
            {
                // Get header information from the supplied sdmxObjects
                senderId = sdmxObjects.Header.Sender.Id;
            }
            else
            {
                // Get header info from HeaderHelper
                senderId = HeaderHelper.Instance.SenderId;
            }

            header.Sender.id = senderId;
        }

        /// <summary>
        /// set the header.
        /// </summary>
        /// <param name="header">
        /// The header.
        /// </param>
        /// <param name="beans">
        /// The beans.
        /// </param>
        /// <param name="receivers">
        /// The receivers.
        /// </param>
        public static void SetHeader(BaseHeaderType header, ISdmxObjects beans, params string[] receivers)
        {
            header.ID = "IDREF" + refNumber;
            refNumber++;
            header.Test = false;
            header.Prepared = DateTime.Now;
            var sender = new SenderType();
            header.Sender = sender;

            string senderId;
            if (beans != null && beans.Header != null && beans.Header.Sender != null)
            {
                // Get header information from the supplied beans
                senderId = beans.Header.Sender.Id;
            }
            else
            {
                // Get header info from HeaderHelper
                senderId = HeaderHelper.Instance.SenderId;
            }

            sender.id = senderId;

            if (ObjectUtil.ValidArray(receivers))
            {
                /* foreach */
                foreach (string currentReviever in receivers)
                {
                    var receiver = new PartyType();
                    header.Receiver.Add(receiver);
                    receiver.id = currentReviever;
                }
            }
            else
            {
                var receiver0 = new PartyType();
                header.Receiver.Add(receiver0);
                receiver0.id = HeaderHelper.Instance.ReceiverId;
            }
        }

        ///////////////////////////////////////////////////////////////////////////////////////////////
        //////////            VERSION 2.0 METHODS FOR STRUCTURES          ///////////////////////////////
        ///////////////////////////////////////////////////////////////////////////////////////////////
        #region Methods

        /// <summary>
        /// Create Categorisations from Version 2.0 categories, adds the categorisations to the sdmxObjects container
        /// </summary>
        /// <param name="beans">
        /// container to add to
        /// </param>
        /// <param name="categoryTypes">
        /// category types to filter on
        /// </param>
        /// <param name="categoryBeans">
        /// category sdmxObjects to process
        /// </param>
        protected internal void ProcessCategory(
            ISdmxObjects beans, IList<CategoryType> categoryTypes, IList<ICategoryObject> categoryBeans)
        {
            if (categoryTypes == null)
            {
                return;
            }

            // Note converted from recursive in Java 0.9.4 to iterative
            var stack = new Stack<KeyValuePair<IList<CategoryType>, IList<ICategoryObject>>>();
            stack.Push(new KeyValuePair<IList<CategoryType>, IList<ICategoryObject>>(categoryTypes, categoryBeans));
            while (stack.Count > 0)
            {
                KeyValuePair<IList<CategoryType>, IList<ICategoryObject>> pair = stack.Pop();
                IList<CategoryType> currentTypes = pair.Key;
                foreach (CategoryType cat in currentTypes)
                {
                    ICategoryObject processingCatBean = null;

                    IList<ICategoryObject> currentObjects = pair.Value;
                    foreach (ICategoryObject currentCatBean in currentObjects)
                    {
                        if (currentCatBean.Id.Equals(cat.id))
                        {
                            processingCatBean = currentCatBean;
                            break;
                        }
                    }

                    // TODO this check doesn't exist in Java 0.9.4
                    if (processingCatBean != null)
                    {
                        stack.Push(
                            new KeyValuePair<IList<CategoryType>, IList<ICategoryObject>>(
                                cat.Category, processingCatBean.Items));
                        this.ProcessCategory(beans, cat, processingCatBean);
                    }
                }
            }
        }

        /// <summary>
        /// Check if the specified structure has all referenced concept schemes from the first keyfamily
        /// </summary>
        /// <param name="structure">
        /// The StructureBean to check
        /// </param>
        public static void CheckConcepts(ISdmxObjects structure)
        {
            var cshtMap = new Dictionary<string, IConceptSchemeObject>();
            IDataStructureObject kf = structure.DataStructures.First();
            foreach (IConceptSchemeObject c in structure.ConceptSchemes)
            {
                cshtMap.Add(Utils.MakeKey(c), c);
            }

            var crossDsd = kf as ICrossSectionalDataStructureObject;

            List<IComponent> components = new List<IComponent>();

            components.AddRange(kf.GetDimensions());
            components.AddRange(kf.Attributes);
            if (kf.PrimaryMeasure != null)
            {
                components.Add(kf.PrimaryMeasure);
            }

            if (crossDsd != null)
            {
                components.AddRange(crossDsd.CrossSectionalMeasures);
            }

            var comps = components;

            foreach (IComponent comp in comps)
            {
                string conceptKey = Utils.MakeKey(comp.ConceptRef.MaintainableReference.MaintainableId,
                    comp.ConceptRef.MaintainableReference.AgencyId, comp.ConceptRef.MaintainableReference.Version);
                if (!cshtMap.ContainsKey(conceptKey))
                {
                    string message = string.Format(CultureInfo.InvariantCulture, Resources.ExceptionMissingConceptSchemeFormat1, conceptKey);
                    Logger.Error(message);
                    throw new NsiClientException(message);
                }
            }
        }

        /// <summary>
        /// Builds a success response along with the query results
        /// </summary>
        /// <param name="beans">
        /// - the beans that were successfully returned from the query
        /// </param>
        /// <param name="schemaVersion">
        /// - the version of the schema to output the response in
        /// </param>
        /// <param name="returnAsStructureMessage">
        /// returns a structure message if true, otherwise returns as a query structure response
        /// </param>
        /// <returns>
        /// The <see cref="XTypedElement"/>.
        /// </returns>
        public virtual XTypedElement BuildSuccessResponse(
            ISdmxObjects beans, SdmxSchemaEnumType schemaVersion, bool returnAsStructureMessage)
        {
            XTypedElement response = null;
            switch (schemaVersion)
            {
                case SdmxSchemaEnumType.VersionTwoPointOne:
                    if (beans.GetAllMaintainables().Count == 0)
                    {
                        response = this._errorResponseBuilder21.BuildErrorResponse(SdmxErrorCodeEnumType.NoResultsFound);
                    }

                    response = this._structV21Builder.Build(beans);
                    break;
                case SdmxSchemaEnumType.VersionTwo:
                    if (returnAsStructureMessage)
                    {
                        response = this._structv2Builder.Build(beans);
                    }

                    response = this._queryStructureResponseBuilderV2.BuildSuccessResponse(beans);
                    break;
                case SdmxSchemaEnumType.VersionOne:
                    response = this._structv1Builder.Build(beans);
                    break;
                default:
                    throw new SdmxNotImplementedException(ExceptionCode.Unsupported, schemaVersion);
            }
            base.WriteSchemaLocation(response, schemaVersion);
            return response;
        }

        public void SaveDotSTATFile(ISdmxObjects sdmxObjects, DotStatExportType exportType)
        {
            string ExportFileName;

            ExportFileName = "DotStatExport-" + sdmxObjects.DataStructures.First().Id + "_" + sdmxObjects.DataStructures.First().AgencyId + "_" + sdmxObjects.DataStructures.First().Version;

            List<ISTAT.IO.Utility.FileGeneric> files = new List<ISTAT.IO.Utility.FileGeneric>();

            List<ContactRef> contacs = GetConfigContact();
            List<SecurityDef> securities = GetConfigSecurity();

            DSDExporter _dsdExp = new DSDExporter(sdmxObjects);

            switch (exportType)
            {
                case DotStatExportType.DSD:
                    if (_dsdExp.CreateData(
                        contacs,
                        securities,
                        true, false))
                    {
                        System.Xml.XmlDocument xDoc = _dsdExp.XMLDoc;

                        MemoryStream xmlStream = new MemoryStream();
                        xDoc.Save(xmlStream);

                        xmlStream.Flush();
                        xmlStream.Position = 0;

                        ISTAT.IO.Utility.FileGeneric file = new ISTAT.IO.Utility.FileGeneric();
                        file.filename = ExportFileName + ".xml";
                        file.stream = xmlStream;

                        files.Add(file);
                    }
                    break;
                case DotStatExportType.CODELIST:
                    if (_dsdExp.CreateData(
                        contacs,
                        securities,
                        true, false))
                    {
                        foreach (CodelistExporter _codeExp in _dsdExp.ExporterCodelists)
                        {
                            System.Xml.XmlDocument xDoc_code = _codeExp.XMLDoc;
                            MemoryStream xmlStream_code = new MemoryStream();
                            xDoc_code.Save(xmlStream_code);
                            xmlStream_code.Flush();
                            xmlStream_code.Position = 0;
                            ISTAT.IO.Utility.FileGeneric file_code = new ISTAT.IO.Utility.FileGeneric();
                            file_code.filename = _codeExp.Code.ToString() + ".xml";
                            file_code.stream = xmlStream_code;
                            files.Add(file_code);

                            Stream streamCSV = CSVWriter.CreateStream(_codeExp.DataView);
                            ISTAT.IO.Utility.FileGeneric file_csv = new ISTAT.IO.Utility.FileGeneric();
                            file_csv.filename = _codeExp.DataFilename;
                            file_csv.stream = streamCSV;
                            files.Add(file_csv);
                        }
                    }
                    break;
                case DotStatExportType.ALL:
                    if (_dsdExp.CreateData(
                        contacs,
                        securities,
                        true, false))
                    {
                        System.Xml.XmlDocument xDoc = _dsdExp.XMLDoc;

                        MemoryStream xmlStream = new MemoryStream();
                        xDoc.Save(xmlStream);

                        xmlStream.Flush();
                        xmlStream.Position = 0;

                        ISTAT.IO.Utility.FileGeneric file = new ISTAT.IO.Utility.FileGeneric();
                        file.filename = ExportFileName + ".xml";
                        file.stream = xmlStream;

                        files.Add(file);
                        foreach (CodelistExporter _codeExp in _dsdExp.ExporterCodelists)
                        {
                            System.Xml.XmlDocument xDoc_code = _codeExp.XMLDoc;
                            MemoryStream xmlStream_code = new MemoryStream();
                            xDoc_code.Save(xmlStream_code);
                            xmlStream_code.Flush();
                            xmlStream_code.Position = 0;
                            ISTAT.IO.Utility.FileGeneric file_code = new ISTAT.IO.Utility.FileGeneric();
                            file_code.filename = _codeExp.Code.ToString() + ".xml";
                            file_code.stream = xmlStream_code;
                            files.Add(file_code);

                            Stream streamCSV = CSVWriter.CreateStream(_codeExp.DataView);
                            ISTAT.IO.Utility.FileGeneric file_csv = new ISTAT.IO.Utility.FileGeneric();
                            file_csv.filename = _codeExp.DataFilename;
                            file_csv.stream = streamCSV;
                            files.Add(file_csv);
                        }
                    }
//.........这里部分代码省略.........

		public InMemoryProvisionRetrievalManager(ISdmxObjects beans0) {
			this.beans = beans0;
		}