mcs/class/referencesource/System.Xml/System/Xml/Schema/NamespaceList.cs

   1 //------------------------------------------------------------------------------
   2 // <copyright file="NamespaceList.cs" company="Microsoft">
   3 //     Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 // <owner current="true" primary="true">Microsoft</owner>
   6 //------------------------------------------------------------------------------
   7
   8
   9 namespace System.Xml.Schema {
  10     using System.Collections;
  11     using System.Text;
  12     using System.Diagnostics;
  13
  14     internal class NamespaceList {
  15         public enum ListType {
  16             Any,
  17             Other,
  18             Set
  19         };
  20
  21         private ListType type = ListType.Any;
  22         private Hashtable set = null;
  23         private string targetNamespace;
  24
  25         public NamespaceList() {
  26         }
  27
  28         public NamespaceList(string namespaces, string targetNamespace) {
  29             Debug.Assert(targetNamespace != null);
  30             this.targetNamespace = targetNamespace;
  31             namespaces = namespaces.Trim();
  32             if (namespaces == "##any" || namespaces.Length == 0) {
  33                 type = ListType.Any;
  34             }
  35             else if (namespaces == "##other") {
  36                 type = ListType.Other;
  37             }
  38             else {
  39                 type = ListType.Set;
  40                 set = new Hashtable();
  41                 string[] splitString = XmlConvert.SplitString(namespaces);
  42                 for (int i = 0; i < splitString.Length; ++i) {
  43                     if (splitString[i] == "##local") {
  44                         set[string.Empty] = string.Empty;
  45                     }
  46                     else if (splitString[i] == "##targetNamespace") {
  47                         set[targetNamespace] = targetNamespace;
  48                     }
  49                     else {
  50                         XmlConvert.ToUri (splitString[i]); // can throw
  51                         set[splitString[i]] = splitString[i];
  52                     }
  53                 }
  54             }
  55         }
  56
  57         public NamespaceList Clone() {
  58             NamespaceList nsl = (NamespaceList)MemberwiseClone();
  59             if (type == ListType.Set) {
  60                 Debug.Assert(set != null);
  61                 nsl.set = (Hashtable)(set.Clone());
  62             }
  63             return nsl;
  64         }
  65
  66         public ListType Type {
  67             get { return type; }
  68         }
  69
  70         public string Excluded {
  71             get { return targetNamespace; }
  72         }
  73
  74         public ICollection Enumerate {
  75             get {
  76                 switch (type) {
  77                 case ListType.Set:
  78                     return set.Keys;
  79                 case ListType.Other:
  80                 case ListType.Any:
  81                 default:
  82                     throw new InvalidOperationException();
  83                 }
  84             }
  85         }
  86
  87         public virtual bool Allows(string ns) {
  88             switch (type) {
  89                 case ListType.Any:
  90                     return true;
  91                 case ListType.Other:
  92                     return ns != targetNamespace && ns.Length != 0;
  93                 case ListType.Set:
  94                     return set[ns] != null;
  95             }
  96             Debug.Assert(false);
  97             return false;
  98         }
  99
 100         public bool Allows(XmlQualifiedName qname) {
 101             return Allows(qname.Namespace);
 102         }
 103
 104         public override string ToString() {
 105             switch (type) {
 106                 case ListType.Any:
 107                     return "##any";
 108                 case ListType.Other:
 109                     return "##other";
 110                 case ListType.Set:
 111                     StringBuilder sb = new StringBuilder();
 112                     bool first = true;
 113                     foreach(string s in set.Keys) {
 114                         if (first) {
 115                             first = false;
 116                         }
 117                         else {
 118                             sb.Append(" ");
 119                         }
 120                         if (s == targetNamespace) {
 121                             sb.Append("##targetNamespace");
 122                         }
 123                         else if (s.Length == 0) {
 124                             sb.Append("##local");
 125                         }
 126                         else {
 127                             sb.Append(s);
 128                         }
 129                     }
 130                     return sb.ToString();
 131             }
 132             Debug.Assert(false);
 133             return string.Empty;
 134         }
 135
 136         public static bool IsSubset(NamespaceList sub, NamespaceList super) {
 137             if (super.type == ListType.Any) {
 138                 return true;
 139             }
 140             else if (sub.type == ListType.Other && super.type == ListType.Other) {
 141                 return super.targetNamespace == sub.targetNamespace;
 142             }
 143             else  if (sub.type == ListType.Set) {
 144                 if (super.type == ListType.Other) {
 145                     return !sub.set.Contains(super.targetNamespace);
 146                 }
 147                 else {
 148                     Debug.Assert(super.type == ListType.Set);
 149                     foreach (string ns in sub.set.Keys) {
 150                         if (!super.set.Contains(ns)) {
 151                             return false;
 152                         }
 153                     }
 154                     return true;
 155                 }
 156             }
 157             return false;
 158         }
 159
 160
 161         public static NamespaceList Union(NamespaceList o1, NamespaceList o2, bool v1Compat) {
 162             NamespaceList nslist = null;
 163             Debug.Assert(o1 != o2);
 164             if (o1.type == ListType.Any) { //clause 2 - o1 is Any
 165                 nslist = new NamespaceList();
 166             }
 167             else if (o2.type == ListType.Any) { //clause 2 - o2 is Any
 168                 nslist = new NamespaceList();
 169             }
 170             else if (o1.type == ListType.Set && o2.type == ListType.Set) { //clause 3 , both are sets
 171                 nslist = o1.Clone();
 172                 foreach (string ns in o2.set.Keys) {
 173                     nslist.set[ns] = ns;
 174                 }
 175             }
 176             else if (o1.type == ListType.Other && o2.type == ListType.Other) { //clause 4, both are negations
 177                 if (o1.targetNamespace == o2.targetNamespace) { //negation of same value
 178                     nslist = o1.Clone();
 179                 }
 180                 else { //Not a breaking change, going from not expressible to not(absent)
 181                     nslist = new NamespaceList("##other", string.Empty); //clause 4, negations of different values, result is not(absent)
 182                 }
 183             }
 184             else if (o1.type == ListType.Set && o2.type == ListType.Other) {
 185                 if (v1Compat) {
 186                     if (o1.set.Contains(o2.targetNamespace)) {
 187                         nslist = new NamespaceList();
 188                     }
 189                     else { //This was not there originally in V1, added for consistency since its not breaking
 190                         nslist = o2.Clone();
 191                     }
 192                 }
 193                 else {
 194                     if (o2.targetNamespace != string.Empty) { //clause 5, o1 is set S, o2 is not(tns)
 195                         nslist = o1.CompareSetToOther(o2);
 196                     }
 197                     else if (o1.set.Contains(string.Empty)) { //clause 6.1 - set S includes absent, o2 is not(absent)
 198                         nslist = new NamespaceList();
 199                     }
 200                     else { //clause 6.2 - set S does not include absent, result is not(absent)
 201                         nslist = new NamespaceList("##other", string.Empty);
 202                     }
 203                 }
 204             }
 205             else if (o2.type == ListType.Set && o1.type == ListType.Other) {
 206                 if (v1Compat) {
 207                     if (o2.set.Contains(o2.targetNamespace)) {
 208                         nslist = new NamespaceList();
 209                     }
 210                     else {
 211                         nslist = o1.Clone();
 212                     }
 213                 }
 214                 else { //New rules
 215                     if (o1.targetNamespace != string.Empty) { //clause 5, o1 is set S, o2 is not(tns)
 216                         nslist = o2.CompareSetToOther(o1);
 217                     }
 218                     else if (o2.set.Contains(string.Empty)) { //clause 6.1 - set S includes absent, o2 is not(absent)
 219                         nslist = new NamespaceList();
 220                     }
 221                     else { //clause 6.2 - set S does not include absent, result is not(absent)
 222                         nslist = new NamespaceList("##other", string.Empty);
 223                     }
 224                 }
 225             }
 226             return nslist;
 227         }
 228
 229         private NamespaceList CompareSetToOther(NamespaceList other) {
 230             //clause 5.1
 231             NamespaceList nslist = null;
 232             if (this.set.Contains(other.targetNamespace)) { //S contains negated ns
 233                 if (this.set.Contains(string.Empty)) { // AND S contains absent
 234                     nslist = new NamespaceList(); //any is the result
 235                 }
 236                 else { //clause 5.2
 237                     nslist = new NamespaceList("##other", string.Empty);
 238                 }
 239             }
 240             else if (this.set.Contains(string.Empty)) { //clause 5.3 - Not expressible
 241                 nslist = null;
 242             }
 243             else { //clause 5.4 - Set S does not contain negated ns or absent
 244                 nslist = other.Clone();
 245             }
 246             return nslist;
 247         }
 248
 249         public static NamespaceList Intersection(NamespaceList o1, NamespaceList o2, bool v1Compat) {
 250             NamespaceList nslist = null;
 251             Debug.Assert(o1 != o2); //clause 1
 252             if (o1.type == ListType.Any) { //clause 2 - o1 is any
 253                 nslist = o2.Clone();
 254             }
 255             else if (o2.type == ListType.Any) { //clause 2 - o2 is any
 256                 nslist = o1.Clone();
 257             }
 258             else if (o1.type == ListType.Set && o2.type == ListType.Other) { //Clause 3 o2 is other
 259                 nslist = o1.Clone();
 260                 nslist.RemoveNamespace(o2.targetNamespace);
 261                 if (!v1Compat) {
 262                     nslist.RemoveNamespace(string.Empty); //remove ##local
 263                 }
 264             }
 265             else if (o1.type == ListType.Other && o2.type == ListType.Set) { //Clause 3 o1 is other
 266                 nslist = o2.Clone();
 267                 nslist.RemoveNamespace(o1.targetNamespace);
 268                 if (!v1Compat) {
 269                     nslist.RemoveNamespace(string.Empty); //remove ##local
 270                 }
 271             }
 272             else if (o1.type == ListType.Set && o2.type == ListType.Set) { //clause 4
 273                 nslist =  o1.Clone();
 274                 nslist = new NamespaceList();
 275                 nslist.type = ListType.Set;
 276                 nslist.set = new Hashtable();
 277                 foreach(string ns in o1.set.Keys) {
 278                     if (o2.set.Contains(ns)) {
 279                         nslist.set.Add(ns, ns);
 280                     }
 281                 }
 282             }
 283             else if (o1.type == ListType.Other && o2.type == ListType.Other) {
 284                 if (o1.targetNamespace == o2.targetNamespace) { //negation of same namespace name
 285                     nslist = o1.Clone();
 286                     return nslist;
 287                 }
 288                 if (!v1Compat) {
 289                     if (o1.targetNamespace == string.Empty) { // clause 6 - o1 is negation of absent
 290                         nslist = o2.Clone();
 291                     }
 292                     else if (o2.targetNamespace == string.Empty) { //clause 6 - o1 is negation of absent
 293                         nslist = o1.Clone();
 294                     }
 295                 }
 296                 //if it comes here, its not expressible //clause 5
 297             }
 298             return nslist;
 299         }
 300
 301         private void RemoveNamespace(string tns) {
 302             if (this.set[tns] != null) {
 303                 this.set.Remove(tns);
 304             }
 305         }
 306
 307         public bool IsEmpty() {
 308             return ((type == ListType.Set) && ((set == null) || set.Count == 0));
 309         }
 310
 311     };
 312
 313     internal class NamespaceListV1Compat : NamespaceList {
 314         public NamespaceListV1Compat(string namespaces, string targetNamespace) : base(namespaces, targetNamespace) {}
 315
 316         public override bool Allows(string ns) {
 317             if (this.Type == ListType.Other) {
 318                 return ns != Excluded;
 319             }
 320             else {
 321                 return base.Allows(ns);
 322             }
 323         }
 324     }
 325 }