ExportSpecialMapping()

XmlSchemaType System.Xml.Serialization.XmlSchemaExporter.ExportSpecialMapping ( SpecialMapping mapping, string ns, bool isAny, XmlSchemaElement element )

inlineprivate

Definition at line 465 of file XmlSchemaExporter.cs.

    {
        switch (mapping.TypeDesc.Kind)
        {
        case TypeKind.Node:
        {
            XmlSchemaComplexType xmlSchemaComplexType4 = new XmlSchemaComplexType();
            xmlSchemaComplexType4.IsMixed = mapping.TypeDesc.IsMixed;
            XmlSchemaSequence xmlSchemaSequence4 = new XmlSchemaSequence();
            XmlSchemaAny xmlSchemaAny3 = new XmlSchemaAny();
            if (isAny)
            {
                xmlSchemaComplexType4.AnyAttribute = new XmlSchemaAnyAttribute();
                xmlSchemaComplexType4.IsMixed = true;
                xmlSchemaAny3.MaxOccurs = decimal.MaxValue;
            }
            xmlSchemaSequence4.Items.Add(xmlSchemaAny3);
            xmlSchemaComplexType4.Particle = xmlSchemaSequence4;
            if (element != null)
            {
                element.SchemaType = xmlSchemaComplexType4;
            }
            return xmlSchemaComplexType4;
        }
        case TypeKind.Serializable:
        {
            SerializableMapping serializableMapping = (SerializableMapping)mapping;
            if (serializableMapping.IsAny)
            {
                XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
                xmlSchemaComplexType.IsMixed = mapping.TypeDesc.IsMixed;
                XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
                XmlSchemaAny xmlSchemaAny = new XmlSchemaAny();
                if (isAny)
                {
                    xmlSchemaComplexType.AnyAttribute = new XmlSchemaAnyAttribute();
                    xmlSchemaComplexType.IsMixed = true;
                    xmlSchemaAny.MaxOccurs = decimal.MaxValue;
                }
                if (serializableMapping.NamespaceList.Length > 0)
                {
                    xmlSchemaAny.Namespace = serializableMapping.NamespaceList;
                }
                xmlSchemaAny.ProcessContents = XmlSchemaContentProcessing.Lax;
                if (serializableMapping.Schemas != null)
                {
                    foreach (XmlSchema item in serializableMapping.Schemas.Schemas())
                    {
                        if (item.TargetNamespace != "http://www.w3.org/2001/XMLSchema")
                        {
                            _schemas.Add(item, delay: true);
                            AddSchemaImport(item.TargetNamespace, ns);
                        }
                    }
                }
                xmlSchemaSequence.Items.Add(xmlSchemaAny);
                xmlSchemaComplexType.Particle = xmlSchemaSequence;
                if (element != null)
                {
                    element.SchemaType = xmlSchemaComplexType;
                }
                return xmlSchemaComplexType;
            }
            if (serializableMapping.XsiType != null || serializableMapping.XsdType != null)
            {
                XmlSchemaType xmlSchemaType = serializableMapping.XsdType;
                foreach (XmlSchema item2 in serializableMapping.Schemas.Schemas())
                {
                    if (item2.TargetNamespace != "http://www.w3.org/2001/XMLSchema")
                    {
                        _schemas.Add(item2, delay: true);
                        AddSchemaImport(item2.TargetNamespace, ns);
                        if (!serializableMapping.XsiType.IsEmpty && serializableMapping.XsiType.Namespace == item2.TargetNamespace)
                        {
                            xmlSchemaType = (XmlSchemaType)item2.SchemaTypes[serializableMapping.XsiType];
                        }
                    }
                }
                if (element != null)
                {
                    element.SchemaTypeName = serializableMapping.XsiType;
                    if (element.SchemaTypeName.IsEmpty)
                    {
                        element.SchemaType = xmlSchemaType;
                    }
                }
                serializableMapping.CheckDuplicateElement(element, ns);
                return xmlSchemaType;
            }
            if (serializableMapping.Schema != null)
            {
                XmlSchemaComplexType xmlSchemaComplexType2 = new XmlSchemaComplexType();
                XmlSchemaAny xmlSchemaAny2 = new XmlSchemaAny();
                XmlSchemaSequence xmlSchemaSequence2 = new XmlSchemaSequence();
                xmlSchemaSequence2.Items.Add(xmlSchemaAny2);
                xmlSchemaComplexType2.Particle = xmlSchemaSequence2;
                string targetNamespace = serializableMapping.Schema.TargetNamespace;
                xmlSchemaAny2.Namespace = ((targetNamespace == null) ? "" : targetNamespace);
                XmlSchema xmlSchema3 = _schemas[targetNamespace];
                if (xmlSchema3 == null)
                {
                    _schemas.Add(serializableMapping.Schema);
                }
                else if (xmlSchema3 != serializableMapping.Schema)
                {
                    throw new InvalidOperationException(System.SR.Format(System.SR.XmlDuplicateNamespace, targetNamespace));
                }
                if (element != null)
                {
                    element.SchemaType = xmlSchemaComplexType2;
                }
                serializableMapping.CheckDuplicateElement(element, ns);
                return xmlSchemaComplexType2;
            }
            XmlSchemaComplexType xmlSchemaComplexType3 = new XmlSchemaComplexType();
            XmlSchemaElement xmlSchemaElement = new XmlSchemaElement();
            xmlSchemaElement.RefName = new XmlQualifiedName("schema", "http://www.w3.org/2001/XMLSchema");
            XmlSchemaSequence xmlSchemaSequence3 = new XmlSchemaSequence();
            xmlSchemaSequence3.Items.Add(xmlSchemaElement);
            xmlSchemaSequence3.Items.Add(new XmlSchemaAny());
            xmlSchemaComplexType3.Particle = xmlSchemaSequence3;
            AddSchemaImport("http://www.w3.org/2001/XMLSchema", ns);
            if (element != null)
            {
                element.SchemaType = xmlSchemaComplexType3;
            }
            return xmlSchemaComplexType3;
        }
        default:
            throw new ArgumentException(System.SR.XmlInternalError, "mapping");
        }
    }

References System.Xml.Serialization.XmlSchemaExporter._schemas, System.Xml.Serialization.XmlSchemas.Add(), System.Xml.Serialization.XmlSchemaExporter.AddSchemaImport(), System.Xml.ArgumentException, System.delay, System.Xml.Dictionary, System.SR.Format(), System.Xml.XmlQualifiedName.IsEmpty, System.item, System.Xml.Schema.XmlSchemaElement.SchemaTypeName, System.SR.XmlDuplicateNamespace, and System.SR.XmlInternalError.

Referenced by System.Xml.Serialization.XmlSchemaExporter.ExportElementMapping(), System.Xml.Serialization.XmlSchemaExporter.ExportMapping(), System.Xml.Serialization.XmlSchemaExporter.ExportRootIfNecessary(), and System.Xml.Serialization.XmlSchemaExporter.ExportTypeMapping().