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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlSchemaDatatype.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.Diagnostics;
  18. using System.ComponentModel;
  19. using System.Xml;
  20. using System.IO;
  21. using System.Globalization;
  22. using System.Text;
  23. namespace System.Xml.Schema
  24. {
  25.    
  26.     /// <include file='doc\XmlSchemaDatatype.uex' path='docs/doc[@for="XmlSchemaDatatype"]/*' />
  27.     /// <devdoc>
  28.     /// <para>[To be supplied.]</para>
  29.     /// </devdoc>
  30.     public abstract class XmlSchemaDatatype
  31.     {
  32.        
  33.         /// <include file='doc\XmlSchemaDatatype.uex' path='docs/doc[@for="XmlSchemaDatatype.ValueType"]/*' />
  34.         /// <devdoc>
  35.         /// <para>[To be supplied.]</para>
  36.         /// </devdoc>
  37.         public abstract Type ValueType {
  38.             get;
  39.         }
  40.        
  41.         /// <include file='doc\XmlSchemaDatatype.uex' path='docs/doc[@for="XmlSchemaDatatype.TokenizedType"]/*' />
  42.         /// <devdoc>
  43.         /// <para>[To be supplied.]</para>
  44.         /// </devdoc>
  45.         public abstract XmlTokenizedType TokenizedType {
  46.             get;
  47.         }
  48.        
  49.         /// <include file='doc\XmlSchemaDatatype.uex' path='docs/doc[@for="XmlSchemaDatatype.ParseValue"]/*' />
  50.         /// <devdoc>
  51.         /// <para>[To be supplied.]</para>
  52.         /// </devdoc>
  53.         public abstract object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr);
  54.        
  55.         /// <include file='doc\XmlSchemaDatatype.uex' path='docs/doc[@for="XmlSchemaDatatype.Variety"]/*' />
  56.         /// <devdoc>
  57.         /// <para>[To be supplied.]</para>
  58.         /// </devdoc>
  59.         public virtual XmlSchemaDatatypeVariety Variety {
  60.             get { return XmlSchemaDatatypeVariety.Atomic; }
  61.         }
  62.        
  63.        
  64.         /// <include file='doc\XmlSchemaDatatype.uex' path='docs/doc[@for="XmlSchemaDatatype.ChangeType1"]/*' />
  65.         /// <devdoc>
  66.         /// <para>[To be supplied.]</para>
  67.         /// </devdoc>
  68.         public virtual object ChangeType(object value, Type targetType)
  69.         {
  70.             if (value == null) {
  71.                 throw new ArgumentNullException("value");
  72.             }
  73.             if (targetType == null) {
  74.                 throw new ArgumentNullException("targetType");
  75.             }
  76.             return ValueConverter.ChangeType(value, targetType);
  77.         }
  78.        
  79.         /// <include file='doc\XmlSchemaDatatype.uex' path='docs/doc[@for="XmlSchemaDatatype.ChangeType2"]/*' />
  80.         /// <devdoc>
  81.         /// <para>[To be supplied.]</para>
  82.         /// </devdoc>
  83.         public virtual object ChangeType(object value, Type targetType, IXmlNamespaceResolver namespaceResolver)
  84.         {
  85.             if (value == null) {
  86.                 throw new ArgumentNullException("value");
  87.             }
  88.             if (targetType == null) {
  89.                 throw new ArgumentNullException("targetType");
  90.             }
  91.             if (namespaceResolver == null) {
  92.                 throw new ArgumentNullException("namespaceResolver");
  93.             }
  94.             return ValueConverter.ChangeType(value, targetType, namespaceResolver);
  95.         }
  96.        
  97.         /// <include file='doc\XmlSchemaDatatype.uex' path='docs/doc[@for="XmlSchemaDatatype.TypeCode"]/*' />
  98.         /// <devdoc>
  99.         /// <para>[To be supplied.]</para>
  100.         /// </devdoc>
  101.         public virtual XmlTypeCode TypeCode {
  102.             get { return XmlTypeCode.None; }
  103.         }
  104.        
  105.         /// <include file='doc\XmlSchemaDatatype.uex' path='docs/doc[@for="XmlSchemaDatatype.IsDerivedFrom"]/*' />
  106.         /// <devdoc>
  107.         /// <para>[To be supplied.]</para>
  108.         /// </devdoc>
  109.         public virtual bool IsDerivedFrom(XmlSchemaDatatype datatype)
  110.         {
  111.             return false;
  112.         }
  113.        
  114.         internal abstract bool HasLexicalFacets {
  115.             get;
  116.         }
  117.        
  118.         internal abstract bool HasValueFacets {
  119.             get;
  120.         }
  121.        
  122.         internal abstract XmlValueConverter ValueConverter {
  123.             get;
  124.         }
  125.        
  126.         internal abstract RestrictionFacets Restriction {
  127.             get;
  128.             set;
  129.         }
  130.        
  131.         internal abstract int Compare(object value1, object value2);
  132.        
  133.         internal abstract object ParseValue(string s, Type typDest, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr);
  134.        
  135.         internal abstract object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, bool createAtomicValue);
  136.        
  137.         internal abstract Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue);
  138.        
  139.         internal abstract Exception TryParseValue(object value, XmlNameTable nameTable, IXmlNamespaceResolver namespaceResolver, out object typedValue);
  140.        
  141.         internal abstract FacetsChecker FacetsChecker {
  142.             get;
  143.         }
  144.        
  145.         internal abstract XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  146.             get;
  147.         }
  148.        
  149.         internal abstract XmlSchemaDatatype DeriveByRestriction(XmlSchemaObjectCollection facets, XmlNameTable nameTable, XmlSchemaType schemaType);
  150.        
  151.         internal abstract XmlSchemaDatatype DeriveByList(XmlSchemaType schemaType);
  152.        
  153.         internal abstract void VerifySchemaValid(XmlSchemaObjectTable notations, XmlSchemaObject caller);
  154.        
  155.         internal abstract bool IsEqual(object o1, object o2);
  156.        
  157.         internal abstract bool IsComparable(XmlSchemaDatatype dtype);
  158.        
  159.         //Error message helper
  160.         internal string TypeCodeString {
  161.             get {
  162.                 string typeCodeString = string.Empty;
  163.                 XmlTypeCode typeCode = this.TypeCode;
  164.                 switch (this.Variety) {
  165.                     case XmlSchemaDatatypeVariety.List:
  166.                         if (typeCode == XmlTypeCode.AnyAtomicType) {
  167.                             //List of union
  168.                             typeCodeString = "List of Union";
  169.                         }
  170.                         else {
  171.                             typeCodeString = "List of " + TypeCodeToString(typeCode);
  172.                         }
  173.                         break;
  174.                     case XmlSchemaDatatypeVariety.Union:
  175.                        
  176.                         typeCodeString = "Union";
  177.                         break;
  178.                     case XmlSchemaDatatypeVariety.Atomic:
  179.                        
  180.                         if (typeCode == XmlTypeCode.AnyAtomicType) {
  181.                             typeCodeString = "anySimpleType";
  182.                         }
  183.                         else {
  184.                             typeCodeString = TypeCodeToString(typeCode);
  185.                         }
  186.                         break;
  187.                 }
  188.                 return typeCodeString;
  189.             }
  190.         }
  191.        
  192.         internal string TypeCodeToString(XmlTypeCode typeCode)
  193.         {
  194.             switch (typeCode) {
  195.                 case XmlTypeCode.None:
  196.                     return "None";
  197.                 case XmlTypeCode.Item:
  198.                     return "AnyType";
  199.                 case XmlTypeCode.AnyAtomicType:
  200.                     return "AnyAtomicType";
  201.                 case XmlTypeCode.String:
  202.                     return "String";
  203.                 case XmlTypeCode.Boolean:
  204.                     return "Boolean";
  205.                 case XmlTypeCode.Decimal:
  206.                     return "Decimal";
  207.                 case XmlTypeCode.Float:
  208.                     return "Float";
  209.                 case XmlTypeCode.Double:
  210.                     return "Double";
  211.                 case XmlTypeCode.Duration:
  212.                     return "Duration";
  213.                 case XmlTypeCode.DateTime:
  214.                     return "DateTime";
  215.                 case XmlTypeCode.Time:
  216.                     return "Time";
  217.                 case XmlTypeCode.Date:
  218.                     return "Date";
  219.                 case XmlTypeCode.GYearMonth:
  220.                     return "GYearMonth";
  221.                 case XmlTypeCode.GYear:
  222.                     return "GYear";
  223.                 case XmlTypeCode.GMonthDay:
  224.                     return "GMonthDay";
  225.                 case XmlTypeCode.GDay:
  226.                     return "GDay";
  227.                 case XmlTypeCode.GMonth:
  228.                     return "GMonth";
  229.                 case XmlTypeCode.HexBinary:
  230.                     return "HexBinary";
  231.                 case XmlTypeCode.Base64Binary:
  232.                     return "Base64Binary";
  233.                 case XmlTypeCode.AnyUri:
  234.                     return "AnyUri";
  235.                 case XmlTypeCode.QName:
  236.                     return "QName";
  237.                 case XmlTypeCode.Notation:
  238.                     return "Notation";
  239.                 case XmlTypeCode.NormalizedString:
  240.                     return "NormalizedString";
  241.                 case XmlTypeCode.Token:
  242.                     return "Token";
  243.                 case XmlTypeCode.Language:
  244.                     return "Language";
  245.                 case XmlTypeCode.NmToken:
  246.                     return "NmToken";
  247.                 case XmlTypeCode.Name:
  248.                     return "Name";
  249.                 case XmlTypeCode.NCName:
  250.                     return "NCName";
  251.                 case XmlTypeCode.Id:
  252.                     return "Id";
  253.                 case XmlTypeCode.Idref:
  254.                     return "Idref";
  255.                 case XmlTypeCode.Entity:
  256.                     return "Entity";
  257.                 case XmlTypeCode.Integer:
  258.                     return "Integer";
  259.                 case XmlTypeCode.NonPositiveInteger:
  260.                     return "NonPositiveInteger";
  261.                 case XmlTypeCode.NegativeInteger:
  262.                     return "NegativeInteger";
  263.                 case XmlTypeCode.Long:
  264.                     return "Long";
  265.                 case XmlTypeCode.Int:
  266.                     return "Int";
  267.                 case XmlTypeCode.Short:
  268.                     return "Short";
  269.                 case XmlTypeCode.Byte:
  270.                     return "Byte";
  271.                 case XmlTypeCode.NonNegativeInteger:
  272.                     return "NonNegativeInteger";
  273.                 case XmlTypeCode.UnsignedLong:
  274.                     return "UnsignedLong";
  275.                 case XmlTypeCode.UnsignedInt:
  276.                     return "UnsignedInt";
  277.                 case XmlTypeCode.UnsignedShort:
  278.                     return "UnsignedShort";
  279.                 case XmlTypeCode.UnsignedByte:
  280.                     return "UnsignedByte";
  281.                 case XmlTypeCode.PositiveInteger:
  282.                     return "PositiveInteger";
  283.                 default:
  284.                    
  285.                     return typeCode.ToString();
  286.             }
  287.         }
  288.        
  289.         static internal string ConcatenatedToString(object value)
  290.         {
  291.             Type t = value.GetType();
  292.             string stringValue = string.Empty;
  293.             if (t == typeof(IEnumerable) && t != typeof(string)) {
  294.                 StringBuilder bldr = new StringBuilder();
  295.                 IEnumerator enumerator = (value as IEnumerable).GetEnumerator();
  296.                 if (enumerator.MoveNext()) {
  297.                     bldr.Append("{");
  298.                     object cur = enumerator.Current;
  299.                     if (cur is IFormattable) {
  300.                         bldr.Append(((IFormattable)cur).ToString("", CultureInfo.InvariantCulture));
  301.                     }
  302.                     else {
  303.                         bldr.Append(cur.ToString());
  304.                     }
  305.                     while (enumerator.MoveNext()) {
  306.                         bldr.Append(" , ");
  307.                         cur = enumerator.Current;
  308.                         if (cur is IFormattable) {
  309.                             bldr.Append(((IFormattable)cur).ToString("", CultureInfo.InvariantCulture));
  310.                         }
  311.                         else {
  312.                             bldr.Append(cur.ToString());
  313.                         }
  314.                     }
  315.                     bldr.Append("}");
  316.                     stringValue = bldr.ToString();
  317.                 }
  318.             }
  319.             else if (value is IFormattable) {
  320.                 stringValue = ((IFormattable)value).ToString("", CultureInfo.InvariantCulture);
  321.             }
  322.             else {
  323.                 stringValue = value.ToString();
  324.             }
  325.             return stringValue;
  326.         }
  327.        
  328.         static internal XmlSchemaDatatype FromXmlTokenizedType(XmlTokenizedType token)
  329.         {
  330.             return DatatypeImplementation.FromXmlTokenizedType(token);
  331.         }
  332.        
  333.         static internal XmlSchemaDatatype FromXmlTokenizedTypeXsd(XmlTokenizedType token)
  334.         {
  335.             return DatatypeImplementation.FromXmlTokenizedTypeXsd(token);
  336.         }
  337.        
  338.         static internal XmlSchemaDatatype FromXdrName(string name)
  339.         {
  340.             return DatatypeImplementation.FromXdrName(name);
  341.         }
  342.        
  343.         static internal XmlSchemaDatatype DeriveByUnion(XmlSchemaSimpleType[] types, XmlSchemaType schemaType)
  344.         {
  345.             return DatatypeImplementation.DeriveByUnion(types, schemaType);
  346.         }
  347.        
  348.         static internal string XdrCanonizeUri(string uri, XmlNameTable nameTable, SchemaNames schemaNames)
  349.         {
  350.             string canonicalUri;
  351.             int offset = 5;
  352.             bool convert = false;
  353.            
  354.             if (uri.Length > 5 && uri.StartsWith("uuid:", StringComparison.Ordinal)) {
  355.                 convert = true;
  356.             }
  357.             else if (uri.Length > 9 && uri.StartsWith("urn:uuid:", StringComparison.Ordinal)) {
  358.                 convert = true;
  359.                 offset = 9;
  360.             }
  361.            
  362.             if (convert) {
  363.                 canonicalUri = nameTable.Add(uri.Substring(0, offset) + uri.Substring(offset, uri.Length - offset).ToUpper(CultureInfo.InvariantCulture));
  364.             }
  365.             else {
  366.                 canonicalUri = uri;
  367.             }
  368.            
  369.             if (Ref.Equal(schemaNames.NsDataTypeAlias, canonicalUri) || Ref.Equal(schemaNames.NsDataTypeOld, canonicalUri)) {
  370.                 canonicalUri = schemaNames.NsDataType;
  371.             }
  372.             else if (Ref.Equal(schemaNames.NsXdrAlias, canonicalUri)) {
  373.                 canonicalUri = schemaNames.NsXdr;
  374.             }
  375.            
  376.             return canonicalUri;
  377.         }
  378.        
  379.     }
  380. }

Developer Fusion