third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/csharp/src/Google.Protobuf/Collections/MapField.cs

 #region Copyright notice and license
 // Protocol Buffers - Google's data interchange format
 // Copyright 2015 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
@@ skipping 12 matching lines @@
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #endregion
 
+using Google.Protobuf.Compatibility;
 using Google.Protobuf.Reflection;
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Text;
-using Google.Protobuf.Compatibility;
 
 namespace Google.Protobuf.Collections
 {
     /// <summary>
     /// Representation of a map field in a Protocol Buffer message.
     /// </summary>
     /// <typeparam name="TKey">Key type in the map. Must be a type supported by Protocol Buffer map keys.</typeparam>
     /// <typeparam name="TValue">Value type in the map. Must be a type supported by Protocol Buffers.</typeparam>
     /// <remarks>
     /// <para>
-    /// This implementation preserves insertion order for simplicity of testing
-    /// code using maps fields. Overwriting an existing entry does not change the
-    /// position of that entry within the map. Equality is not order-sensitive.
     /// For string keys, the equality comparison is provided by <see cref="StringComparer.Ordinal" />.
     /// </para>
     /// <para>
     /// Null values are not permitted in the map, either for wrapper types or regular messages.
     /// If a map is deserialized from a data stream and the value is missing from an entry, a default value
     /// is created instead. For primitive types, that is the regular default value (0, the empty string and so
     /// on); for message types, an empty instance of the message is created, as if the map entry contained a 0-length
     /// encoded value for the field.
     /// </para>
     /// <para>
     /// This implementation does not generally prohibit the use of key/value types which are not
     /// supported by Protocol Buffers (e.g. using a key type of <code>byte</code>) but nor does it guarantee
     /// that all operations will work in such cases.
     /// </para>
+    /// <para>
+    /// The order in which entries are returned when iterating over this object is undefined, and may change
+    /// in future versions.
+    /// </para>
     /// </remarks>
     public sealed class MapField<TKey, TValue> : IDeepCloneable<MapField<TKey, TValue>>, IDictionary<TKey, TValue>, IEquatable<MapField<TKey, TValue>>, IDictionary
     {
         // TODO: Don't create the map/list until we have an entry. (Assume many maps will be empty.)
         private readonly Dictionary<TKey, LinkedListNode<KeyValuePair<TKey, TValue>>> map =
             new Dictionary<TKey, LinkedListNode<KeyValuePair<TKey, TValue>>>();
         private readonly LinkedList<KeyValuePair<TKey, TValue>> list = new LinkedList<KeyValuePair<TKey, TValue>>();
 
         /// <summary>
         /// Creates a deep clone of this object.
@@ skipping 27 matching lines @@
         /// This operation fails if the key already exists in the map. To replace an existing entry, use the indexer.
         /// </remarks>
         /// <param name="key">The key to add</param>
         /// <param name="value">The value to add.</param>
         /// <exception cref="System.ArgumentException">The given key already exists in map.</exception>
         public void Add(TKey key, TValue value)
         {
             // Validation of arguments happens in ContainsKey and the indexer
             if (ContainsKey(key))
             {
-                throw new ArgumentException("Key already exists in map", "key");
+                throw new ArgumentException("Key already exists in map", nameof(key));
             }
             this[key] = value;
         }
 
         /// <summary>
         /// Determines whether the specified key is present in the map.
         /// </summary>
         /// <param name="key">The key to check.</param>
         /// <returns><c>true</c> if the map contains the given key; <c>false</c> otherwise.</returns>
         public bool ContainsKey(TKey key)
         {
-            ProtoPreconditions.CheckNotNullUnconstrained(key, "key");
+            ProtoPreconditions.CheckNotNullUnconstrained(key, nameof(key));
             return map.ContainsKey(key);
         }
 
         private bool ContainsValue(TValue value)
         {
             var comparer = EqualityComparer<TValue>.Default;
             return list.Any(pair => comparer.Equals(pair.Value, value));
         }
 
         /// <summary>
         /// Removes the entry identified by the given key from the map.
         /// </summary>
         /// <param name="key">The key indicating the entry to remove from the map.</param>
         /// <returns><c>true</c> if the map contained the given key before the entry was removed; <c>false</c> otherwise.</returns>
         public bool Remove(TKey key)
         {
-            ProtoPreconditions.CheckNotNullUnconstrained(key, "key");
+            ProtoPreconditions.CheckNotNullUnconstrained(key, nameof(key));
             LinkedListNode<KeyValuePair<TKey, TValue>> node;
             if (map.TryGetValue(key, out node))
             {
                 map.Remove(key);
                 node.List.Remove(node);
                 return true;
             }
             else
             {
                 return false;
@@ skipping 27 matching lines @@
         /// Gets or sets the value associated with the specified key.
         /// </summary>
         /// <param name="key">The key of the value to get or set.</param>
         /// <exception cref="KeyNotFoundException">The property is retrieved and key does not exist in the collection.</exception>
         /// <returns>The value associated with the specified key. If the specified key is not found,
         /// a get operation throws a <see cref="KeyNotFoundException"/>, and a set operation creates a new element with the specified key.</returns>
         public TValue this[TKey key]
         {
             get
             {
-                ProtoPreconditions.CheckNotNullUnconstrained(key, "key");
+                ProtoPreconditions.CheckNotNullUnconstrained(key, nameof(key));
                 TValue value;
                 if (TryGetValue(key, out value))
                 {
                     return value;
                 }
                 throw new KeyNotFoundException();
             }
             set
             {
-                ProtoPreconditions.CheckNotNullUnconstrained(key, "key");
+                ProtoPreconditions.CheckNotNullUnconstrained(key, nameof(key));
                 // value == null check here is redundant, but avoids boxing.
                 if (value == null)
                 {
-                    ProtoPreconditions.CheckNotNullUnconstrained(value, "value");
+                    ProtoPreconditions.CheckNotNullUnconstrained(value, nameof(value));
                 }
                 LinkedListNode<KeyValuePair<TKey, TValue>> node;
                 var pair = new KeyValuePair<TKey, TValue>(key, value);
                 if (map.TryGetValue(key, out node))
                 {
                     node.Value = pair;
                 }
                 else
                 {
                     node = list.AddLast(pair);
@@ skipping 11 matching lines @@
         /// Gets a collection containing the values in the map.
         /// </summary>
         public ICollection<TValue> Values { get { return new MapView<TValue>(this, pair => pair.Value, ContainsValue); } }
 
         /// <summary>
         /// Adds the specified entries to the map. The keys and values are not automatically cloned.
         /// </summary>
         /// <param name="entries">The entries to add to the map.</param>
         public void Add(IDictionary<TKey, TValue> entries)
         {
-            ProtoPreconditions.CheckNotNull(entries, "entries");
+            ProtoPreconditions.CheckNotNull(entries, nameof(entries));
             foreach (var pair in entries)
             {
                 Add(pair.Key, pair.Value);
             }
         }
 
         /// <summary>
         /// Returns an enumerator that iterates through the collection.
         /// </summary>
         /// <returns>
@@ skipping 58 matching lines @@
         /// <summary>
         /// Removes the specified key/value pair from the map.
         /// </summary>
         /// <remarks>Both the key and the value must be found for the entry to be removed.</remarks>
         /// <param name="item">The key/value pair to remove.</param>
         /// <returns><c>true</c> if the key/value pair was found and removed; <c>false</c> otherwise.</returns>
         bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
         {
             if (item.Key == null)
             {
-                throw new ArgumentException("Key is null", "item");
+                throw new ArgumentException("Key is null", nameof(item));
             }
             LinkedListNode<KeyValuePair<TKey, TValue>> node;
             if (map.TryGetValue(item.Key, out node) &&
                 EqualityComparer<TValue>.Default.Equals(item.Value, node.Value.Value))
             {
                 map.Remove(item.Key);
                 node.List.Remove(node);
                 return true;
             }
             else
@@ skipping 167 matching lines @@
             return ContainsKey((TKey)key);
         }
 
         IDictionaryEnumerator IDictionary.GetEnumerator()
         {
             return new DictionaryEnumerator(GetEnumerator());
         }
 
         void IDictionary.Remove(object key)
         {
-            ProtoPreconditions.CheckNotNull(key, "key");
+            ProtoPreconditions.CheckNotNull(key, nameof(key));
             if (!(key is TKey))
             {
                 return;
             }
             Remove((TKey)key);
         }
 
         void ICollection.CopyTo(Array array, int index)
         {
             // This is ugly and slow as heck, but with any luck it will never be used anyway.
             ICollection temp = this.Select(pair => new DictionaryEntry(pair.Key, pair.Value)).ToList();
             temp.CopyTo(array, index);
         }
 
         bool IDictionary.IsFixedSize { get { return false; } }
 
         ICollection IDictionary.Keys { get { return (ICollection)Keys; } }
 
         ICollection IDictionary.Values { get { return (ICollection)Values; } }
 
         bool ICollection.IsSynchronized { get { return false; } }
 
         object ICollection.SyncRoot { get { return this; } }
 
         object IDictionary.this[object key]
         {
             get
             {
-                ProtoPreconditions.CheckNotNull(key, "key");
+                ProtoPreconditions.CheckNotNull(key, nameof(key));
                 if (!(key is TKey))
                 {
                     return null;
                 }
                 TValue value;
                 TryGetValue((TKey)key, out value);
                 return value;
             }
 
             set
@@ skipping 161 matching lines @@
 
             public bool Contains(T item)
             {
                 return containsCheck(item);
             }
 
             public void CopyTo(T[] array, int arrayIndex)
             {
                 if (arrayIndex < 0)
                 {
-                    throw new ArgumentOutOfRangeException("arrayIndex");
+                    throw new ArgumentOutOfRangeException(nameof(arrayIndex));
                 }
                 if (arrayIndex + Count  >= array.Length)
                 {
-                    throw new ArgumentException("Not enough space in the array", "array");
+                    throw new ArgumentException("Not enough space in the array", nameof(array));
                 }
                 foreach (var item in this)
                 {
                     array[arrayIndex++] = item;
                 }
             }
 
             public IEnumerator<T> GetEnumerator()
             {
                 return parent.list.Select(projection).GetEnumerator();
             }
 
             public bool Remove(T item)
             {
                 throw new NotSupportedException();
             }
 
             IEnumerator IEnumerable.GetEnumerator()
             {
                 return GetEnumerator();
             }
 
             public void CopyTo(Array array, int index)
             {
                 if (index < 0)
                 {
-                    throw new ArgumentOutOfRangeException("index");
+                    throw new ArgumentOutOfRangeException(nameof(index));
                 }
                 if (index + Count >= array.Length)
                 {
-                    throw new ArgumentException("Not enough space in the array", "array");
+                    throw new ArgumentException("Not enough space in the array", nameof(array));
                 }
                 foreach (var item in this)
                 {
                     array.SetValue(item, index++);
                 }
             }
         }
     }
 }