Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

external/referencesource/System.Runtime.Serialization/System/Xml/StringHandle.cs

@@ -0,0 +1,300 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.Xml
+{
+    using System.Runtime;
+
+    enum StringHandleConstStringType
+    {
+        Type = 0,
+        Root = 1,
+        Item = 2
+    }
+
+    class StringHandle
+    {
+        XmlBufferReader bufferReader;
+        StringHandleType type;
+        int key;
+        int offset;
+        int length;
+        static string[] constStrings = {
+                                            "type",
+                                            "root",
+                                            "item"
+                                       };
+
+        public StringHandle(XmlBufferReader bufferReader)
+        {
+            this.bufferReader = bufferReader;
+            SetValue(0, 0);
+        }
+
+        public void SetValue(int offset, int length)
+        {
+            this.type = StringHandleType.UTF8;
+            this.offset = offset;
+            this.length = length;
+        }
+
+        public void SetConstantValue(StringHandleConstStringType constStringType)
+        {
+            type = StringHandleType.ConstString;
+            key = (int)constStringType;
+        }
+
+        public void SetValue(int offset, int length, bool escaped)
+        {
+            this.type = (escaped ? StringHandleType.EscapedUTF8 : StringHandleType.UTF8);
+            this.offset = offset;
+            this.length = length;
+        }
+
+        public void SetValue(int key)
+        {
+            this.type = StringHandleType.Dictionary;
+            this.key = key;
+        }
+
+        public void SetValue(StringHandle value)
+        {
+            this.type = value.type;
+            this.key = value.key;
+            this.offset = value.offset;
+            this.length = value.length;
+        }
+
+        public bool IsEmpty
+        {
+            get
+            {
+                if (type == StringHandleType.UTF8)
+                    return length == 0;
+                return Equals2(string.Empty);
+            }
+        }
+
+        public bool IsXmlns
+        {
+            get
+            {
+                if (type == StringHandleType.UTF8)
+                {
+                    if (this.length != 5)
+                        return false;
+                    byte[] buffer = bufferReader.Buffer;
+                    int offset = this.offset;
+                    return buffer[offset + 0] == 'x' &&
+                           buffer[offset + 1] == 'm' &&
+                           buffer[offset + 2] == 'l' &&
+                           buffer[offset + 3] == 'n' &&
+                           buffer[offset + 4] == 's';
+                }
+                return Equals2("xmlns");
+            }
+        }
+
+        public void ToPrefixHandle(PrefixHandle prefix)
+        {
+            Fx.Assert(type == StringHandleType.UTF8, "");
+            prefix.SetValue(offset, length);
+        }
+
+        public string GetString(XmlNameTable nameTable)
+        {
+            StringHandleType type = this.type;
+            if (type == StringHandleType.UTF8)
+                return bufferReader.GetString(offset, length, nameTable);
+            if (type == StringHandleType.Dictionary)
+                return nameTable.Add(bufferReader.GetDictionaryString(key).Value);
+            if (type == StringHandleType.ConstString)
+                return nameTable.Add(constStrings[key]);
+            Fx.Assert(type == StringHandleType.EscapedUTF8, "");
+            return bufferReader.GetEscapedString(offset, length, nameTable);
+        }
+
+        public string GetString()
+        {
+            StringHandleType type = this.type;
+            if (type == StringHandleType.UTF8)
+                return bufferReader.GetString(offset, length);
+            if (type == StringHandleType.Dictionary)
+                return bufferReader.GetDictionaryString(key).Value;
+            if (type == StringHandleType.ConstString)
+                return constStrings[key];
+            Fx.Assert(type == StringHandleType.EscapedUTF8, "");
+            return bufferReader.GetEscapedString(offset, length);
+        }
+
+        public byte[] GetString(out int offset, out int length)
+        {
+            StringHandleType type = this.type;
+            if (type == StringHandleType.UTF8)
+            {
+                offset = this.offset;
+                length = this.length;
+                return bufferReader.Buffer;
+            }
+            if (type == StringHandleType.Dictionary)
+            {
+                byte[] buffer = bufferReader.GetDictionaryString(this.key).ToUTF8();
+                offset = 0;
+                length = buffer.Length;
+                return buffer;
+            }
+            if (type == StringHandleType.ConstString)
+            {
+                byte[] buffer = XmlConverter.ToBytes(constStrings[key]);
+                offset = 0;
+                length = buffer.Length;
+                return buffer;
+            }
+            else
+            {
+                Fx.Assert(type == StringHandleType.EscapedUTF8, "");
+                byte[] buffer = XmlConverter.ToBytes(bufferReader.GetEscapedString(this.offset, this.length));
+                offset = 0;
+                length = buffer.Length;
+                return buffer;
+            }
+        }
+
+        public bool TryGetDictionaryString(out XmlDictionaryString value)
+        {
+            if (type == StringHandleType.Dictionary)
+            {
+                value = bufferReader.GetDictionaryString(key);
+                return true;
+            }
+            else if (IsEmpty)
+            {
+                value = XmlDictionaryString.Empty;
+                return true;
+            }
+
+            value = null;
+            return false;
+        }
+
+        public override string ToString()
+        {
+            return GetString();
+        }
+
+        bool Equals2(int key2, XmlBufferReader bufferReader2)
+        {
+            StringHandleType type = this.type;
+            if (type == StringHandleType.Dictionary)
+                return bufferReader.Equals2(this.key, key2, bufferReader2);
+            if (type == StringHandleType.UTF8)
+                return bufferReader.Equals2(this.offset, this.length, bufferReader2.GetDictionaryString(key2).Value);
+            Fx.Assert(type == StringHandleType.EscapedUTF8 || type == StringHandleType.ConstString, "");
+            return GetString() == bufferReader.GetDictionaryString(key2).Value;
+        }
+
+        bool Equals2(XmlDictionaryString xmlString2)
+        {
+            StringHandleType type = this.type;
+            if (type == StringHandleType.Dictionary)
+                return bufferReader.Equals2(this.key, xmlString2);
+            if (type == StringHandleType.UTF8)
+                return bufferReader.Equals2(this.offset, this.length, xmlString2.ToUTF8());
+            Fx.Assert(type == StringHandleType.EscapedUTF8 || type == StringHandleType.ConstString, "");
+            return GetString() == xmlString2.Value;
+        }
+
+        bool Equals2(string s2)
+        {
+            StringHandleType type = this.type;
+            if (type == StringHandleType.Dictionary)
+                return bufferReader.GetDictionaryString(this.key).Value == s2;
+            if (type == StringHandleType.UTF8)
+                return bufferReader.Equals2(this.offset, this.length, s2);
+            Fx.Assert(type == StringHandleType.EscapedUTF8 || type == StringHandleType.ConstString, "");
+            return GetString() == s2;
+        }
+
+        bool Equals2(int offset2, int length2, XmlBufferReader bufferReader2)
+        {
+            StringHandleType type = this.type;
+            if (type == StringHandleType.Dictionary)
+                return bufferReader2.Equals2(offset2, length2, bufferReader.GetDictionaryString(this.key).Value);
+            if (type == StringHandleType.UTF8)
+                return bufferReader.Equals2(this.offset, this.length, bufferReader2, offset2, length2);
+            Fx.Assert(type == StringHandleType.EscapedUTF8 || type == StringHandleType.ConstString, "");
+            return GetString() == bufferReader.GetString(offset2, length2);
+        }
+
+        bool Equals2(StringHandle s2)
+        {
+            StringHandleType type = s2.type;
+            if (type == StringHandleType.Dictionary)
+                return Equals2(s2.key, s2.bufferReader);
+            if (type == StringHandleType.UTF8)
+                return Equals2(s2.offset, s2.length, s2.bufferReader);
+            Fx.Assert(type == StringHandleType.EscapedUTF8 || type == StringHandleType.ConstString, "");
+            return Equals2(s2.GetString());
+        }
+
+        static public bool operator ==(StringHandle s1, XmlDictionaryString xmlString2)
+        {
+            return s1.Equals2(xmlString2);
+        }
+
+        static public bool operator !=(StringHandle s1, XmlDictionaryString xmlString2)
+        {
+            return !s1.Equals2(xmlString2);
+        }
+
+        static public bool operator ==(StringHandle s1, string s2)
+        {
+            return s1.Equals2(s2);
+        }
+
+        static public bool operator !=(StringHandle s1, string s2)
+        {
+            return !s1.Equals2(s2);
+        }
+
+        static public bool operator ==(StringHandle s1, StringHandle s2)
+        {
+            return s1.Equals2(s2);
+        }
+
+        static public bool operator !=(StringHandle s1, StringHandle s2)
+        {
+            return !s1.Equals2(s2);
+        }
+
+        public int CompareTo(StringHandle that)
+        {
+            if (this.type == StringHandleType.UTF8 && that.type == StringHandleType.UTF8)
+                return bufferReader.Compare(this.offset, this.length, that.offset, that.length);
+            else
+                return string.Compare(this.GetString(), that.GetString(), StringComparison.Ordinal);
+        }
+
+        public override bool Equals(object obj)
+        {
+            StringHandle that = obj as StringHandle;
+            if (object.ReferenceEquals(that, null))
+                return false;
+            return this == that;
+        }
+
+        public override int GetHashCode()
+        {
+            return GetString().GetHashCode();
+        }
+
+        enum StringHandleType
+        {
+            Dictionary,
+            UTF8,
+            EscapedUTF8,
+            ConstString
+        }
+    }
+}