Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Xml/System/Xml/Serialization/Advanced/SchemaImporterExtension.cs

@@ -0,0 +1,192 @@
+//------------------------------------------------------------------------------
+// <copyright file="IXmlSerializable.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+// <owner current="true" primary="true">[....]</owner>                                                                
+//------------------------------------------------------------------------------
+
+namespace System.Xml.Serialization.Advanced {
+
+    using System.Xml.Schema;
+    using System.Xml;
+    using System.Collections;
+    using System.Collections.Specialized;
+    using System.CodeDom;
+    using System.CodeDom.Compiler;
+    using System.Xml.Serialization;
+
+    /// <include file='doc\SchemaImporterExtension.uex' path='docs/doc[@for="SchemaImporterExtension"]/*' />
+    ///<internalonly/>
+    /// <devdoc>
+    ///    <para>[To be supplied.]</para>
+    /// </devdoc>
+    public abstract class SchemaImporterExtension {
+        /// <include file='doc\SchemaImporterExtension.uex' path='docs/doc[@for="SchemaImporterExtension.ImportSchemaType"]/*' />
+        public virtual string ImportSchemaType(string name, string ns, XmlSchemaObject context, XmlSchemas schemas, XmlSchemaImporter importer, 
+            CodeCompileUnit compileUnit, CodeNamespace mainNamespace, CodeGenerationOptions options, CodeDomProvider codeProvider) {
+            return null;
+        }
+
+        /// <include file='doc\SchemaImporterExtension.uex' path='docs/doc[@for="SchemaImporterExtension.ImportSchemaType1"]/*' />
+        public virtual string ImportSchemaType(XmlSchemaType type, XmlSchemaObject context, XmlSchemas schemas, XmlSchemaImporter importer,
+            CodeCompileUnit compileUnit, CodeNamespace mainNamespace, CodeGenerationOptions options, CodeDomProvider codeProvider) {
+            return null;
+        }
+
+        /// <include file='doc\SchemaImporterExtension.uex' path='docs/doc[@for="SchemaImporterExtension.ImportSchemaType1"]/*' />
+        public virtual string ImportAnyElement(XmlSchemaAny any, bool mixed, XmlSchemas schemas, XmlSchemaImporter importer,
+            CodeCompileUnit compileUnit, CodeNamespace mainNamespace, CodeGenerationOptions options, CodeDomProvider codeProvider) {
+            return null;
+        }
+
+        /// <include file='doc\SchemaImporterExtension.uex' path='docs/doc[@for="SchemaImporterExtension.ImportDefaultValue"]/*' />
+        public virtual CodeExpression ImportDefaultValue(string value, string type) {
+            return null;
+        }
+    }
+
+    public class SchemaImporterExtensionCollection : CollectionBase {
+        Hashtable exNames;
+
+        internal Hashtable Names {
+            get {
+                if (exNames == null)
+                    exNames = new Hashtable();
+                return exNames;
+            }
+        }
+
+        public int Add(SchemaImporterExtension extension) {
+            return Add(extension.GetType().FullName, extension);
+        }
+
+        public int Add(string name, Type type) {
+            if (type.IsSubclassOf(typeof(SchemaImporterExtension))) {
+                return Add(name, (SchemaImporterExtension)Activator.CreateInstance(type));
+            }
+            else {
+                throw new ArgumentException(Res.GetString(Res.XmlInvalidSchemaExtension, type));
+            }
+        }
+        
+        public void Remove(string name) {
+            if (Names[name] != null) {
+                List.Remove(Names[name]);
+                Names[name] = null;
+            }
+        }
+
+        public new void Clear() {
+            Names.Clear();
+            List.Clear();
+        }
+
+        internal SchemaImporterExtensionCollection Clone() {
+            SchemaImporterExtensionCollection clone = new SchemaImporterExtensionCollection();
+            clone.exNames = (Hashtable)this.Names.Clone();
+            foreach (object o in this.List) {
+                clone.List.Add(o);
+            }
+            return clone;
+        }
+
+        public SchemaImporterExtension this[int index] {
+            get { return (SchemaImporterExtension)List[index]; }
+            set { List[index] = value; }
+        }
+
+        internal int Add(string name, SchemaImporterExtension extension) {
+            if (Names[name] != null) {
+                if (Names[name].GetType() != extension.GetType()) {
+                    throw new InvalidOperationException(Res.GetString(Res.XmlConfigurationDuplicateExtension, name));
+                }
+                return -1;
+            }
+            Names[name] = extension;
+            return List.Add(extension);
+        }
+        
+        public void Insert(int index, SchemaImporterExtension extension) {
+            List.Insert(index, extension);
+        }
+        
+        public int IndexOf(SchemaImporterExtension extension) {
+            return List.IndexOf(extension);
+        }
+        
+        public bool Contains(SchemaImporterExtension extension) {
+            return List.Contains(extension);
+        }
+        
+        public void Remove(SchemaImporterExtension extension) {
+            List.Remove(extension);
+        }
+        
+        public void CopyTo(SchemaImporterExtension[] array, int index) {
+            List.CopyTo(array, index);
+        }
+    }
+
+    internal class MappedTypeDesc {
+        string name;
+        string ns;
+        XmlSchemaType xsdType;
+        XmlSchemaObject context;
+        string clrType;
+        SchemaImporterExtension extension;
+        CodeNamespace code;
+        bool exported = false;
+        StringCollection references;
+
+        internal MappedTypeDesc(string clrType, string name, string ns, XmlSchemaType xsdType, XmlSchemaObject context, SchemaImporterExtension extension, CodeNamespace code, StringCollection references) {
+            this.clrType = clrType.Replace('+', '.');
+            this.name = name;
+            this.ns = ns;
+            this.xsdType = xsdType;
+            this.context = context;
+            this.code = code;
+            this.references = references;
+            this.extension = extension;
+        }
+
+        internal SchemaImporterExtension Extension { get { return extension; } }
+        internal string Name { get { return clrType; } }
+        
+        internal StringCollection ReferencedAssemblies { 
+            get { 
+                if (references == null)
+                    references = new StringCollection();
+                return references; 
+            } 
+        }
+
+        internal CodeTypeDeclaration ExportTypeDefinition(CodeNamespace codeNamespace, CodeCompileUnit codeCompileUnit) {
+            if (exported)
+                return null;
+            exported = true;
+
+            foreach(CodeNamespaceImport import in code.Imports) {
+                codeNamespace.Imports.Add(import);
+            }
+            CodeTypeDeclaration codeClass = null;
+            string comment = Res.GetString(Res.XmlExtensionComment, extension.GetType().FullName);
+            foreach(CodeTypeDeclaration type in code.Types) {
+                if (clrType == type.Name) {
+                    if (codeClass != null)
+                        throw new InvalidOperationException(Res.GetString(Res.XmlExtensionDuplicateDefinition, extension.GetType().FullName, clrType));
+                    codeClass = type;
+                }
+                type.Comments.Add(new CodeCommentStatement(comment, false));
+                codeNamespace.Types.Add(type);
+            }
+            if (codeCompileUnit != null) {
+                foreach(string reference in ReferencedAssemblies) {
+                    if (codeCompileUnit.ReferencedAssemblies.Contains(reference))
+                        continue;
+                    codeCompileUnit.ReferencedAssemblies.Add(reference);
+                }
+            }
+            return codeClass;
+        }
+    }
+}