Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

external/referencesource/System.ServiceModel/System/ServiceModel/Channels/ContextDictionary.cs

@@ -0,0 +1,230 @@
+//----------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//----------------------------------------------------------------
+
+namespace System.ServiceModel.Channels
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Collections.ObjectModel;
+    using System.Runtime;
+
+    [Serializable]
+    class ContextDictionary : IDictionary<string, string>
+    {
+        static ContextDictionary empty;
+
+        IDictionary<string, string> dictionaryStore;
+
+        public ContextDictionary()
+        {
+            this.dictionaryStore = new Dictionary<string, string>();
+        }
+
+        public ContextDictionary(IDictionary<string, string> context)
+        {
+            this.dictionaryStore = new Dictionary<string, string>();
+
+            if (context != null)
+            {
+                bool ignoreValidation = context is ContextDictionary;
+
+                foreach (KeyValuePair<string, string> pair in context)
+                {
+                    if (ignoreValidation)
+                    {
+                        this.dictionaryStore.Add(pair);
+                    }
+                    else
+                    {
+                        this.Add(pair);
+                    }
+                }
+            }
+        }
+
+        internal static ContextDictionary Empty
+        {
+            get
+            {
+                if (empty == null)
+                {
+                    ContextDictionary localEmpty = new ContextDictionary();
+                    localEmpty.dictionaryStore = new ReadOnlyDictionaryInternal<string, string>(new Dictionary<string, string>(0));
+                    empty = localEmpty;
+                }
+
+                return empty;
+            }
+        }
+
+        public int Count
+        {
+            get { return this.dictionaryStore.Count; }
+        }
+
+        public bool IsReadOnly
+        {
+            get { return this.dictionaryStore.IsReadOnly; }
+        }
+
+        public ICollection<string> Keys
+        {
+            get { return this.dictionaryStore.Keys; }
+        }
+
+        public ICollection<string> Values
+        {
+            get { return this.dictionaryStore.Values; }
+        }
+
+        public string this[string key]
+        {
+            get
+            {
+                ValidateKeyValueSpace(key);
+                return this.dictionaryStore[key];
+            }
+            set
+            {
+                if (value == null)
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value");
+                }
+                ValidateKeyValueSpace(key);
+                this.dictionaryStore[key] = value;
+            }
+        }
+
+        public void Add(string key, string value)
+        {
+            if (value == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value");
+            }
+
+            ValidateKeyValueSpace(key);
+            this.dictionaryStore.Add(key, value);
+        }
+
+
+        public void Add(KeyValuePair<string, string> item)
+        {
+            if (item.Key == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item.Key");
+            }
+            if (item.Value == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item.Value");
+            }
+            ValidateKeyValueSpace(item.Key);
+            this.dictionaryStore.Add(item);
+        }
+
+        public void Clear()
+        {
+            this.dictionaryStore.Clear();
+        }
+
+        public bool Contains(KeyValuePair<string, string> item)
+        {
+            if (item.Key == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item.Key");
+            }
+            if (item.Value == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item.Value");
+            }
+
+            ValidateKeyValueSpace(item.Key);
+            return this.dictionaryStore.Contains(item);
+        }
+
+
+        public bool ContainsKey(string key)
+        {
+            ValidateKeyValueSpace(key);
+            return this.dictionaryStore.ContainsKey(key);
+        }
+
+        public void CopyTo(KeyValuePair<string, string>[] array, int arrayIndex)
+        {
+            this.dictionaryStore.CopyTo(array, arrayIndex);
+        }
+
+
+        public IEnumerator<KeyValuePair<string, string>> GetEnumerator()
+        {
+            return this.dictionaryStore.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((IEnumerable)this.dictionaryStore).GetEnumerator();
+        }
+
+        public bool Remove(string key)
+        {
+            ValidateKeyValueSpace(key);
+            return this.dictionaryStore.Remove(key);
+        }
+
+        public bool Remove(KeyValuePair<string, string> item)
+        {
+            if (item.Key == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item.Key");
+            }
+            if (item.Value == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item.Value");
+            }
+
+            ValidateKeyValueSpace(item.Key);
+            return this.dictionaryStore.Remove(item);
+        }
+
+        public bool TryGetValue(string key, out string value)
+        {
+            ValidateKeyValueSpace(key);
+            return this.dictionaryStore.TryGetValue(key, out value);
+        }
+
+        internal static bool TryValidateKeyValueSpace(string key)
+        {
+            if (string.IsNullOrEmpty(key))
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("key");
+            }
+
+            for (int counter = 0; counter < key.Length; ++counter)
+            {
+                char currentCharacter = key[counter];
+
+                if (!IsLetterOrDigit(currentCharacter) && currentCharacter != '-' && currentCharacter != '_' && currentCharacter != '.')
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        static bool IsLetterOrDigit(char c)
+        {
+            return (('A' <= c) && (c <= 'Z')) ||
+                (('a' <= c) && (c <= 'z')) ||
+                (('0' <= c) && (c <= '9'));
+        }
+
+        static void ValidateKeyValueSpace(string key)
+        {
+            if (!TryValidateKeyValueSpace(key))
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("key", SR.GetString(SR.InvalidCookieContent, key)));
+            }
+        }
+    }
+}