NamespaceList.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Xml / System / Xml / schema / NamespaceList.cs / 1305376 / NamespaceList.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
//-----------------------------------------------------------------------------
 
 
namespace System.Xml.Schema {
    using System.Collections; 
    using System.Text;
    using System.Diagnostics;

    internal class NamespaceList { 
        public enum ListType {
            Any, 
            Other, 
            Set
        }; 

        private ListType type = ListType.Any;
        private Hashtable set = null;
        private string targetNamespace; 

        public NamespaceList() { 
        } 

        public NamespaceList(string namespaces, string targetNamespace) { 
            Debug.Assert(targetNamespace != null);
            this.targetNamespace = targetNamespace;
            namespaces = namespaces.Trim();
            if (namespaces == "##any" || namespaces.Length == 0) { 
                type = ListType.Any;
            } 
            else if (namespaces == "##other") { 
                type = ListType.Other;
            } 
            else {
                type = ListType.Set;
                set = new Hashtable();
                string[] splitString = XmlConvert.SplitString(namespaces); 
                for (int i = 0; i < splitString.Length; ++i) {
                    if (splitString[i] == "##local") { 
                        set[string.Empty] = string.Empty; 
                    }
                    else if (splitString[i] == "##targetNamespace") { 
                        set[targetNamespace] = targetNamespace;
                    }
                    else {
                        XmlConvert.ToUri (splitString[i]); // can throw 
                        set[splitString[i]] = splitString[i];
                    } 
                } 
            }
        } 

        public NamespaceList Clone() {
            NamespaceList nsl = (NamespaceList)MemberwiseClone();
            if (type == ListType.Set) { 
                Debug.Assert(set != null);
                nsl.set = (Hashtable)(set.Clone()); 
            } 
            return nsl;
        } 

        public ListType Type {
            get { return type; }
        } 

        public string Excluded { 
            get { return targetNamespace; } 
        }
 
        public ICollection Enumerate {
            get {
                switch (type) {
                case ListType.Set: 
                    return set.Keys;
                case ListType.Other: 
                case ListType.Any: 
                default:
                    throw new InvalidOperationException(); 
                }
            }
        }
 
        public virtual bool Allows(string ns) {
            switch (type) { 
                case ListType.Any: 
                    return true;
                case ListType.Other: 
                    return ns != targetNamespace && ns.Length != 0;
                case ListType.Set:
                    return set[ns] != null;
            } 
            Debug.Assert(false);
            return false; 
        } 

        public bool Allows(XmlQualifiedName qname) { 
            return Allows(qname.Namespace);
        }

        public override string ToString() { 
            switch (type) {
                case ListType.Any: 
                    return "##any"; 
                case ListType.Other:
                    return "##other"; 
                case ListType.Set:
                    StringBuilder sb = new StringBuilder();
                    bool first = true;
                    foreach(string s in set.Keys) { 
                        if (first) {
                            first = false; 
                        } 
                        else {
                            sb.Append(" "); 
                        }
                        if (s == targetNamespace) {
                            sb.Append("##targetNamespace");
                        } 
                        else if (s.Length == 0) {
                            sb.Append("##local"); 
                        } 
                        else {
                            sb.Append(s); 
                        }
                    }
                    return sb.ToString();
            } 
            Debug.Assert(false);
            return string.Empty; 
        } 

        public static bool IsSubset(NamespaceList sub, NamespaceList super) { 
            if (super.type == ListType.Any) {
                return true;
            }
            else if (sub.type == ListType.Other && super.type == ListType.Other) { 
                return super.targetNamespace == sub.targetNamespace;
            } 
            else  if (sub.type == ListType.Set) { 
                if (super.type == ListType.Other) {
                    return !sub.set.Contains(super.targetNamespace); 
                }
                else {
                    Debug.Assert(super.type == ListType.Set);
                    foreach (string ns in sub.set.Keys) { 
                        if (!super.set.Contains(ns)) {
                            return false; 
                        } 
                    }
                    return true; 
                }
            }
            return false;
        } 

 
        public static NamespaceList Union(NamespaceList o1, NamespaceList o2, bool v1Compat) { 
            NamespaceList nslist = null;
            Debug.Assert(o1 != o2); 
            if (o1.type == ListType.Any) { //clause 2 - o1 is Any
                nslist = new NamespaceList();
            }
            else if (o2.type == ListType.Any) { //clause 2 - o2 is Any 
                nslist = new NamespaceList();
            } 
            else if (o1.type == ListType.Set && o2.type == ListType.Set) { //clause 3 , both are sets 
                nslist = o1.Clone();
                foreach (string ns in o2.set.Keys) { 
                    nslist.set[ns] = ns;
                }
            }
            else if (o1.type == ListType.Other && o2.type == ListType.Other) { //clause 4, both are negations 
                if (o1.targetNamespace == o2.targetNamespace) { //negation of same value
                    nslist = o1.Clone(); 
                } 
                else { //Not a breaking change, going from not expressible to not(absent)
                    nslist = new NamespaceList("##other", string.Empty); //clause 4, negations of different values, result is not(absent) 
                }
            }
            else if (o1.type == ListType.Set && o2.type == ListType.Other) {
                if (v1Compat) { 
                    if (o1.set.Contains(o2.targetNamespace)) {
                        nslist = new NamespaceList(); 
                    } 
                    else { //This was not there originally in V1, added for consistency since its not breaking
                        nslist = o2.Clone(); 
                    }
                }
                else {
                    if (o2.targetNamespace != string.Empty) { //clause 5, o1 is set S, o2 is not(tns) 
                        nslist = o1.CompareSetToOther(o2);
                    } 
                    else if (o1.set.Contains(string.Empty)) { //clause 6.1 - set S includes absent, o2 is not(absent) 
                        nslist = new NamespaceList();
                    } 
                    else { //clause 6.2 - set S does not include absent, result is not(absent)
                        nslist = new NamespaceList("##other", string.Empty);
                    }
                } 
            }
            else if (o2.type == ListType.Set && o1.type == ListType.Other) { 
                if (v1Compat) { 
                    if (o2.set.Contains(o2.targetNamespace)) {
                        nslist = new NamespaceList(); 
                    }
                    else {
                        nslist = o1.Clone();
                    } 
                }
                else { //New rules 
                    if (o1.targetNamespace != string.Empty) { //clause 5, o1 is set S, o2 is not(tns) 
                        nslist = o2.CompareSetToOther(o1);
                    } 
                    else if (o2.set.Contains(string.Empty)) { //clause 6.1 - set S includes absent, o2 is not(absent)
                        nslist = new NamespaceList();
                    }
                    else { //clause 6.2 - set S does not include absent, result is not(absent) 
                        nslist = new NamespaceList("##other", string.Empty);
                    } 
                } 
            }
            return nslist; 
        }

        private NamespaceList CompareSetToOther(NamespaceList other) {
            //clause 5.1 
            NamespaceList nslist = null;
            if (this.set.Contains(other.targetNamespace)) { //S contains negated ns 
                if (this.set.Contains(string.Empty)) { // AND S contains absent 
                    nslist = new NamespaceList(); //any is the result
                } 
                else { //clause 5.2
                    nslist = new NamespaceList("##other", string.Empty);
                }
            } 
            else if (this.set.Contains(string.Empty)) { //clause 5.3 - Not expressible
                nslist = null; 
            } 
            else { //clause 5.4 - Set S does not contain negated ns or absent
                nslist = other.Clone(); 
            }
            return nslist;
        }
 
        public static NamespaceList Intersection(NamespaceList o1, NamespaceList o2, bool v1Compat) {
            NamespaceList nslist = null; 
            Debug.Assert(o1 != o2); //clause 1 
            if (o1.type == ListType.Any) { //clause 2 - o1 is any
                nslist = o2.Clone(); 
            }
            else if (o2.type == ListType.Any) { //clause 2 - o2 is any
                nslist = o1.Clone();
            } 
            else if (o1.type == ListType.Set && o2.type == ListType.Other) { //Clause 3 o2 is other
                nslist = o1.Clone(); 
                nslist.RemoveNamespace(o2.targetNamespace); 
                if (!v1Compat) {
                    nslist.RemoveNamespace(string.Empty); //remove ##local 
                }
            }
            else if (o1.type == ListType.Other && o2.type == ListType.Set) { //Clause 3 o1 is other
                nslist = o2.Clone(); 
                nslist.RemoveNamespace(o1.targetNamespace);
                if (!v1Compat) { 
                    nslist.RemoveNamespace(string.Empty); //remove ##local 
                }
            } 
            else if (o1.type == ListType.Set && o2.type == ListType.Set) { //clause 4
                nslist =  o1.Clone();
                nslist = new NamespaceList();
                nslist.type = ListType.Set; 
                nslist.set = new Hashtable();
                foreach(string ns in o1.set.Keys) { 
                    if (o2.set.Contains(ns)) { 
                        nslist.set.Add(ns, ns);
                    } 
                }
            }
            else if (o1.type == ListType.Other && o2.type == ListType.Other) {
                if (o1.targetNamespace == o2.targetNamespace) { //negation of same namespace name 
                    nslist = o1.Clone();
                    return nslist; 
                } 
                if (!v1Compat) {
                    if (o1.targetNamespace == string.Empty) { // clause 6 - o1 is negation of absent 
                        nslist = o2.Clone();
                    }
                    else if (o2.targetNamespace == string.Empty) { //clause 6 - o1 is negation of absent
                        nslist = o1.Clone(); 
                    }
                } 
                //if it comes here, its not expressible //clause 5 
            }
            return nslist; 
        }

        private void RemoveNamespace(string tns) {
            if (this.set[tns] != null) { 
                this.set.Remove(tns);
            } 
        } 

        public bool IsEmpty() { 
            return ((type == ListType.Set) && ((set == null) || set.Count == 0));
        }

    }; 

    internal class NamespaceListV1Compat : NamespaceList { 
        public NamespaceListV1Compat(string namespaces, string targetNamespace) : base(namespaces, targetNamespace) {} 

        public override bool Allows(string ns) { 
            if (this.Type == ListType.Other) {
                return ns != Excluded;
            }
            else { 
                return base.Allows(ns);
            } 
        } 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK