The Labs \ Source Viewer \ SSCLI \ System.Xml \ XmlNameEx

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlName.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. //------------------------------------------------------------------------------
  15. namespace System.Xml
  16. {
  17.     using System.Text;
  18.     using System.Diagnostics;
  19.     using System.Xml.Schema;
  20.    
  21.     internal class XmlName : IXmlSchemaInfo
  22.     {
  23.         string prefix;
  24.         string localName;
  25.         string ns;
  26.         string name;
  27.         int hashCode;
  28.         internal XmlDocument ownerDoc;
  29.         internal XmlName next;
  30.        
  31.         public static XmlName Create(string prefix, string localName, string ns, int hashCode, XmlDocument ownerDoc, XmlName next, IXmlSchemaInfo schemaInfo)
  32.         {
  33.             if (schemaInfo == null) {
  34.                 return new XmlName(prefix, localName, ns, hashCode, ownerDoc, next);
  35.             }
  36.             else {
  37.                 return new XmlNameEx(prefix, localName, ns, hashCode, ownerDoc, next, schemaInfo);
  38.             }
  39.         }
  40.        
  41.         internal XmlName(string prefix, string localName, string ns, int hashCode, XmlDocument ownerDoc, XmlName next)
  42.         {
  43.             this.prefix = prefix;
  44.             this.localName = localName;
  45.             this.ns = ns;
  46.             this.name = null;
  47.             this.hashCode = hashCode;
  48.             this.ownerDoc = ownerDoc;
  49.             this.next = next;
  50.         }
  51.        
  52.         public string LocalName {
  53.             get { return localName; }
  54.         }
  55.        
  56.         public string NamespaceURI {
  57.             get { return ns; }
  58.         }
  59.        
  60.         public string Prefix {
  61.             get { return prefix; }
  62.         }
  63.        
  64.         public int HashCode {
  65.             get { return hashCode; }
  66.         }
  67.        
  68.         public XmlDocument OwnerDocument {
  69.             get { return ownerDoc; }
  70.         }
  71.        
  72.         public string Name {
  73.             get {
  74.                 if (name == null) {
  75.                     Debug.Assert(prefix != null);
  76.                     if (prefix.Length > 0) {
  77.                         if (localName.Length > 0) {
  78.                             string n = string.Concat(prefix, ":", localName);
  79.                             lock (ownerDoc.NameTable) {
  80.                                 if (name == null) {
  81.                                     name = ownerDoc.NameTable.Add(n);
  82.                                 }
  83.                             }
  84.                         }
  85.                         else {
  86.                             name = prefix;
  87.                         }
  88.                     }
  89.                     else {
  90.                         name = localName;
  91.                     }
  92.                     Debug.Assert(Ref.Equal(name, ownerDoc.NameTable.Get(name)));
  93.                 }
  94.                 return name;
  95.             }
  96.         }
  97.        
  98.         public virtual XmlSchemaValidity Validity {
  99.             get { return XmlSchemaValidity.NotKnown; }
  100.         }
  101.        
  102.         public virtual bool IsDefault {
  103.             get { return false; }
  104.         }
  105.        
  106.         public virtual bool IsNil {
  107.             get { return false; }
  108.         }
  109.        
  110.         public virtual XmlSchemaSimpleType MemberType {
  111.             get { return null; }
  112.         }
  113.        
  114.         public virtual XmlSchemaType SchemaType {
  115.             get { return null; }
  116.         }
  117.        
  118.         public virtual XmlSchemaElement SchemaElement {
  119.             get { return null; }
  120.         }
  121.        
  122.         public virtual XmlSchemaAttribute SchemaAttribute {
  123.             get { return null; }
  124.         }
  125.        
  126.         public virtual bool Equals(IXmlSchemaInfo schemaInfo)
  127.         {
  128.             return schemaInfo == null;
  129.         }
  130.        
  131.         public static int GetHashCode(string name)
  132.         {
  133.             int hashCode = 0;
  134.             if (name != null) {
  135.                 for (int i = name.Length - 1; i >= 0; i--) {
  136.                     char ch = name[i];
  137.                     if (ch == ':')
  138.                         break;
  139.                     hashCode += (hashCode << 7) ^ ch;
  140.                 }
  141.                 hashCode -= hashCode >> 17;
  142.                 hashCode -= hashCode >> 11;
  143.                 hashCode -= hashCode >> 5;
  144.             }
  145.             return hashCode;
  146.         }
  147.     }
  148.    
  149.     internal sealed class XmlNameEx : XmlName
  150.     {
  151.         byte flags;
  152.         XmlSchemaSimpleType memberType;
  153.         XmlSchemaType schemaType;
  154.         object decl;
  155.        
  156.         // flags
  157.         // 0,1 : Validity
  158.         // 2 : IsDefault
  159.         // 3 : IsNil
  160.         const byte ValidityMask = 3;
  161.         const byte IsDefaultBit = 4;
  162.         const byte IsNilBit = 8;
  163.        
  164.         internal XmlNameEx(string prefix, string localName, string ns, int hashCode, XmlDocument ownerDoc, XmlName next, IXmlSchemaInfo schemaInfo) : base(prefix, localName, ns, hashCode, ownerDoc, next)
  165.         {
  166.             SetValidity(schemaInfo.Validity);
  167.             SetIsDefault(schemaInfo.IsDefault);
  168.             SetIsNil(schemaInfo.IsNil);
  169.             memberType = schemaInfo.MemberType;
  170.             schemaType = schemaInfo.SchemaType;
  171.             decl = schemaInfo.SchemaElement != null ? (object)schemaInfo.SchemaElement : (object)schemaInfo.SchemaAttribute;
  172.         }
  173.        
  174.         public override XmlSchemaValidity Validity {
  175.             get { return ownerDoc.CanReportValidity ? (XmlSchemaValidity)(flags & ValidityMask) : XmlSchemaValidity.NotKnown; }
  176.         }
  177.        
  178.         public override bool IsDefault {
  179.             get { return (flags & IsDefaultBit) != 0; }
  180.         }
  181.        
  182.         public override bool IsNil {
  183.             get { return (flags & IsNilBit) != 0; }
  184.         }
  185.        
  186.         public override XmlSchemaSimpleType MemberType {
  187.             get { return memberType; }
  188.         }
  189.        
  190.         public override XmlSchemaType SchemaType {
  191.             get { return schemaType; }
  192.         }
  193.        
  194.         public override XmlSchemaElement SchemaElement {
  195.             get { return decl as XmlSchemaElement; }
  196.         }
  197.        
  198.         public override XmlSchemaAttribute SchemaAttribute {
  199.             get { return decl as XmlSchemaAttribute; }
  200.         }
  201.        
  202.         public void SetValidity(XmlSchemaValidity value)
  203.         {
  204.             flags = (byte)((flags & ~ValidityMask) | (byte)(value));
  205.         }
  206.        
  207.         public void SetIsDefault(bool value)
  208.         {
  209.             if (value)
  210.                 flags = (byte)(flags | IsDefaultBit);
  211.             else
  212.                 flags = (byte)(flags & ~IsDefaultBit);
  213.         }
  214.        
  215.         public void SetIsNil(bool value)
  216.         {
  217.             if (value)
  218.                 flags = (byte)(flags | IsNilBit);
  219.             else
  220.                 flags = (byte)(flags & ~IsNilBit);
  221.         }
  222.        
  223.         public override bool Equals(IXmlSchemaInfo schemaInfo)
  224.         {
  225.             if (schemaInfo != null && schemaInfo.Validity == (XmlSchemaValidity)(flags & ValidityMask) && schemaInfo.IsDefault == ((flags & IsDefaultBit) != 0) && schemaInfo.IsNil == ((flags & IsNilBit) != 0) && (object)schemaInfo.MemberType == (object)memberType && (object)schemaInfo.SchemaType == (object)schemaType && (object)schemaInfo.SchemaElement == (object)(decl as XmlSchemaElement) && (object)schemaInfo.SchemaAttribute == (object)(decl as XmlSchemaAttribute)) {
  226.                 return true;
  227.             }
  228.             return false;
  229.         }
  230.     }
  231. }

Developer Fusion