mcs/class/referencesource/System.Xml/System/Xml/Dom/XmlName.cs

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