The Labs \ Source Viewer \ SSCLI \ System.Xml.Schema \ XmlSchemaType

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlSchemaType.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. // <owner current="true" primary="true">priyal</owner>
  15. //------------------------------------------------------------------------------
  16. using System.Collections;
  17. using System.ComponentModel;
  18. using System.Xml.Serialization;
  19. namespace System.Xml.Schema
  20. {
  21.    
  22.    
  23.     /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType"]/*' />
  24.     /// <devdoc>
  25.     /// <para>[To be supplied.]</para>
  26.     /// </devdoc>
  27.     public class XmlSchemaType : XmlSchemaAnnotated
  28.     {
  29.         string name;
  30.         XmlSchemaDerivationMethod final = XmlSchemaDerivationMethod.None;
  31.         XmlSchemaDerivationMethod derivedBy;
  32.         XmlSchemaType baseSchemaType;
  33.         XmlSchemaDatatype datatype;
  34.         XmlSchemaDerivationMethod finalResolved;
  35.         SchemaElementDecl elementDecl;
  36.         XmlQualifiedName qname = XmlQualifiedName.Empty;
  37.         XmlSchemaType redefined;
  38.        
  39.         //compiled information
  40.         XmlSchemaContentType contentType;
  41.        
  42.         /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.GetXsdSimpleType"]/*' />
  43.         /// <devdoc>
  44.         /// <para>[To be supplied.]</para>
  45.         /// </devdoc>
  46.         public static XmlSchemaSimpleType GetBuiltInSimpleType(XmlQualifiedName qualifiedName)
  47.         {
  48.             if (qualifiedName == null) {
  49.                 throw new ArgumentNullException("qualifiedName");
  50.             }
  51.             return DatatypeImplementation.GetSimpleTypeFromXsdType(qualifiedName);
  52.         }
  53.        
  54.         /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.GetXsdSimpleType"]/*' />
  55.         /// <devdoc>
  56.         /// <para>[To be supplied.]</para>
  57.         /// </devdoc>
  58.         public static XmlSchemaSimpleType GetBuiltInSimpleType(XmlTypeCode typeCode)
  59.         {
  60.             return DatatypeImplementation.GetSimpleTypeFromTypeCode(typeCode);
  61.         }
  62.        
  63.         /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.GetXsdComplexType"]/*' />
  64.         /// <devdoc>
  65.         /// <para>[To be supplied.]</para>
  66.         /// </devdoc>
  67.         public static XmlSchemaComplexType GetBuiltInComplexType(XmlTypeCode typeCode)
  68.         {
  69.             if (typeCode == XmlTypeCode.Item) {
  70.                 return XmlSchemaComplexType.AnyType;
  71.             }
  72.             return null;
  73.         }
  74.        
  75.         /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.GetXsdComplexType"]/*' />
  76.         /// <devdoc>
  77.         /// <para>[To be supplied.]</para>
  78.         /// </devdoc>
  79.         public static XmlSchemaComplexType GetBuiltInComplexType(XmlQualifiedName qualifiedName)
  80.         {
  81.             if (qualifiedName == null) {
  82.                 throw new ArgumentNullException("qualifiedName");
  83.             }
  84.             if (qualifiedName.Equals(XmlSchemaComplexType.AnyType.QualifiedName)) {
  85.                 return XmlSchemaComplexType.AnyType;
  86.             }
  87.             if (qualifiedName.Equals(XmlSchemaComplexType.UntypedAnyType.QualifiedName)) {
  88.                 return XmlSchemaComplexType.UntypedAnyType;
  89.             }
  90.             return null;
  91.         }
  92.        
  93.         /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.Name"]/*' />
  94.         /// <devdoc>
  95.         /// <para>[To be supplied.]</para>
  96.         /// </devdoc>
  97.         [XmlAttribute("name")]
  98.         public string Name {
  99.             get { return name; }
  100.             set { name = value; }
  101.         }
  102.        
  103.         /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.Final"]/*' />
  104.         /// <devdoc>
  105.         /// <para>[To be supplied.]</para>
  106.         /// </devdoc>
  107.         [XmlAttribute("final"), DefaultValue(XmlSchemaDerivationMethod.None)]
  108.         public XmlSchemaDerivationMethod Final {
  109.             get { return final; }
  110.             set { final = value; }
  111.         }
  112.        
  113.         /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.QualifiedName"]/*' />
  114.         /// <devdoc>
  115.         /// <para>[To be supplied.]</para>
  116.         /// </devdoc>
  117.         [XmlIgnore()]
  118.         public XmlQualifiedName QualifiedName {
  119.             get { return qname; }
  120.         }
  121.        
  122.         /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.FinalResolved"]/*' />
  123.         /// <devdoc>
  124.         /// <para>[To be supplied.]</para>
  125.         /// </devdoc>
  126.         [XmlIgnore()]
  127.         public XmlSchemaDerivationMethod FinalResolved {
  128.             get { return finalResolved; }
  129.         }
  130.        
  131.         /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.BaseSchemaType"]/*' />
  132.         /// <devdoc>
  133.         /// <para>[To be supplied.]</para>
  134.         /// </devdoc>
  135.         [XmlIgnore()]
  136.         [Obsolete("This property has been deprecated. Please use BaseXmlSchemaType property that returns a strongly typed base schema type. http://go.microsoft.com/fwlink/?linkid=14202")]
  137.         public object BaseSchemaType {
  138.             get {
  139.                 if (baseSchemaType.QualifiedName.Namespace == XmlReservedNs.NsXs) {
  140.                     return baseSchemaType.Datatype;
  141.                 }
  142.                 return baseSchemaType;
  143.             }
  144.         }
  145.        
  146.         /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.BaseSchemaType"]/*' />
  147.         /// <devdoc>
  148.         /// <para>[To be supplied.]</para>
  149.         /// </devdoc>
  150.         [XmlIgnore()]
  151.         public XmlSchemaType BaseXmlSchemaType {
  152.             get { return baseSchemaType; }
  153.         }
  154.        
  155.         /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.DerivedBy"]/*' />
  156.         /// <devdoc>
  157.         /// <para>[To be supplied.]</para>
  158.         /// </devdoc>
  159.         [XmlIgnore()]
  160.         public XmlSchemaDerivationMethod DerivedBy {
  161.             get { return derivedBy; }
  162.         }
  163.        
  164.         /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.Datatype"]/*' />
  165.         /// <devdoc>
  166.         /// <para>[To be supplied.]</para>
  167.         /// </devdoc>
  168.         [XmlIgnore()]
  169.         public XmlSchemaDatatype Datatype {
  170.             get { return datatype; }
  171.         }
  172.        
  173.         /// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.IsMixed"]/*' />
  174.         /// <devdoc>
  175.         /// <para>[To be supplied.]</para>
  176.         /// </devdoc>
  177.         [XmlIgnore()]
  178.         public virtual bool IsMixed {
  179.             get { return false; }
  180.             set {
  181.                 ;
  182.             }
  183.         }
  184.        
  185.         [XmlIgnore()]
  186.         public XmlTypeCode TypeCode {
  187.             get {
  188.                 if (this == XmlSchemaComplexType.AnyType) {
  189.                     return XmlTypeCode.Item;
  190.                 }
  191.                 if (datatype == null) {
  192.                     return XmlTypeCode.None;
  193.                 }
  194.                 return datatype.TypeCode;
  195.             }
  196.         }
  197.        
  198.         [XmlIgnore()]
  199.         internal XmlValueConverter ValueConverter {
  200.             get {
  201.                 if (datatype == null) {
  202.                     //Default converter
  203.                     return XmlUntypedConverter.Untyped;
  204.                 }
  205.                 return datatype.ValueConverter;
  206.             }
  207.         }
  208.        
  209.         internal XmlReader Validate(XmlReader reader, XmlResolver resolver, XmlSchemaSet schemaSet, ValidationEventHandler valEventHandler)
  210.         {
  211.             if (schemaSet != null) {
  212.                 XmlReaderSettings readerSettings = new XmlReaderSettings();
  213.                 readerSettings.ValidationType = ValidationType.Schema;
  214.                 readerSettings.Schemas = schemaSet;
  215.                 readerSettings.ValidationEventHandler += valEventHandler;
  216.                 return new XsdValidatingReader(reader, resolver, readerSettings, this);
  217.             }
  218.             return null;
  219.         }
  220.        
  221.         internal XmlSchemaContentType SchemaContentType {
  222.             get { return contentType; }
  223.         }
  224.        
  225.         internal void SetQualifiedName(XmlQualifiedName value)
  226.         {
  227.             qname = value;
  228.         }
  229.        
  230.         internal void SetFinalResolved(XmlSchemaDerivationMethod value)
  231.         {
  232.             finalResolved = value;
  233.         }
  234.        
  235.         internal void SetBaseSchemaType(XmlSchemaType value)
  236.         {
  237.             baseSchemaType = value;
  238.         }
  239.        
  240.         internal void SetDerivedBy(XmlSchemaDerivationMethod value)
  241.         {
  242.             derivedBy = value;
  243.         }
  244.        
  245.         internal void SetDatatype(XmlSchemaDatatype value)
  246.         {
  247.             datatype = value;
  248.         }
  249.        
  250.         internal SchemaElementDecl ElementDecl {
  251.             get { return elementDecl; }
  252.             set { elementDecl = value; }
  253.         }
  254.        
  255.         [XmlIgnore()]
  256.         internal XmlSchemaType Redefined {
  257.             get { return redefined; }
  258.             set { redefined = value; }
  259.         }
  260.        
  261.         internal virtual XmlQualifiedName DerivedFrom {
  262.             get { return XmlQualifiedName.Empty; }
  263.         }
  264.        
  265.         internal void SetContentType(XmlSchemaContentType value)
  266.         {
  267.             contentType = value;
  268.         }
  269.        
  270.         public static bool IsDerivedFrom(XmlSchemaType derivedType, XmlSchemaType baseType, XmlSchemaDerivationMethod except)
  271.         {
  272.             if (derivedType == null || baseType == null) {
  273.                 return false;
  274.             }
  275.            
  276.             if (derivedType == baseType) {
  277.                 return true;
  278.             }
  279.            
  280.             if (baseType == XmlSchemaComplexType.AnyType) {
  281.                 //Not checking for restriction blocked since all types are implicitly derived by restriction from xs:anyType
  282.                 return true;
  283.             }
  284.             do {
  285.                 XmlSchemaSimpleType dt = derivedType as XmlSchemaSimpleType;
  286.                 XmlSchemaSimpleType bt = baseType as XmlSchemaSimpleType;
  287.                 if (bt != null && dt != null) {
  288.                     //SimpleTypes
  289.                     if (bt == DatatypeImplementation.AnySimpleType) {
  290.                         //Not checking block=restriction
  291.                         return true;
  292.                     }
  293.                     if ((except & derivedType.DerivedBy) != 0 || !dt.Datatype.IsDerivedFrom(bt.Datatype)) {
  294.                         return false;
  295.                     }
  296.                     return true;
  297.                 }
  298.                 else {
  299.                     //Complex types
  300.                     if ((except & derivedType.DerivedBy) != 0) {
  301.                         return false;
  302.                     }
  303.                     derivedType = derivedType.BaseXmlSchemaType;
  304.                     if (derivedType == baseType) {
  305.                         return true;
  306.                     }
  307.                 }
  308.                
  309.             }
  310.             while (derivedType != null);
  311.            
  312.             return false;
  313.         }
  314.        
  315.        
  316.         static internal bool IsDerivedFromDatatype(XmlSchemaDatatype derivedDataType, XmlSchemaDatatype baseDataType, XmlSchemaDerivationMethod except)
  317.         {
  318.             if (DatatypeImplementation.AnySimpleType.Datatype == baseDataType) {
  319.                 return true;
  320.             }
  321.             return derivedDataType.IsDerivedFrom(baseDataType);
  322.         }
  323.        
  324.         [XmlIgnore()]
  325.         internal override string NameAttribute {
  326.             get { return Name; }
  327.             set { Name = value; }
  328.         }
  329.     }
  330.    
  331. }

Developer Fusion