Reverts third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/csharp/src/Google.Protobuf/Collections/RepeatedField.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 16 matching lines @@
 // 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 System;
 using System.Collections;
 using System.Collections.Generic;
 using System.IO;
+using System.Text;
 
 namespace Google.Protobuf.Collections
 {
     /// <summary>
     /// The contents of a repeated field: essentially, a collection with some extra
     /// restrictions (no null values) and capabilities (deep cloning).
     /// </summary>
     /// <remarks>
     /// This implementation does not generally prohibit the use of types which are not
     /// supported by Protocol Buffers but nor does it guarantee that all operations will work in such cases.
@@ skipping 172 matching lines @@
                 array = tmp;
             }
         }
 
         /// <summary>
         /// Adds the specified item to the collection.
         /// </summary>
         /// <param name="item">The item to add.</param>
         public void Add(T item)
         {
-            ProtoPreconditions.CheckNotNullUnconstrained(item, nameof(item));
+            if (item == null)
+            {
+                throw new ArgumentNullException("item");
+            }
             EnsureSize(count + 1);
             array[count++] = item;
         }
 
         /// <summary>
         /// Removes all items from the collection.
         /// </summary>
         public void Clear()
         {
             array = EmptyArray;
@@ skipping 34 matching lines @@
             }            
             Array.Copy(array, index + 1, array, index, count - index - 1);
             count--;
             array[count] = default(T);
             return true;
         }
 
         /// <summary>
         /// Gets the number of elements contained in the collection.
         /// </summary>
-        public int Count => count;
+        public int Count { get { return count; } }
 
         /// <summary>
         /// Gets a value indicating whether the collection is read-only.
         /// </summary>
-        public bool IsReadOnly => false;
+        public bool IsReadOnly { get { return false; } }
+
+        // TODO: Remove this overload and just handle it in the one below, at execution time?
 
         /// <summary>
         /// Adds all of the specified values into this collection.
         /// </summary>
         /// <param name="values">The values to add to this collection.</param>
-        public void AddRange(IEnumerable<T> values)
+        public void Add(RepeatedField<T> values)
         {
-            ProtoPreconditions.CheckNotNull(values, nameof(values));
+            if (values == null)
+            {
+                throw new ArgumentNullException("values");
+            }
+            EnsureSize(count + values.count);
+            // We know that all the values will be valid, because it's a RepeatedField.
+            Array.Copy(values.array, 0, array, count, values.count);
+            count += values.count;
+        }
 
-            // Optimization 1: If the collection we're adding is already a RepeatedField<T>,
-            // we know the values are valid.
-            var otherRepeatedField = values as RepeatedField<T>;
-            if (otherRepeatedField != null)
+        /// <summary>
+        /// Adds all of the specified values into this collection.
+        /// </summary>
+        /// <param name="values">The values to add to this collection.</param>
+        public void Add(IEnumerable<T> values)
+        {
+            if (values == null)
             {
-                EnsureSize(count + otherRepeatedField.count);
-                Array.Copy(otherRepeatedField.array, 0, array, count, otherRepeatedField.count);
-                count += otherRepeatedField.count;
-                return;
+                throw new ArgumentNullException("values");
             }
-
-            // Optimization 2: The collection is an ICollection, so we can expand
-            // just once and ask the collection to copy itself into the array.
-            var collection = values as ICollection;
-            if (collection != null)
-            {
-                var extraCount = collection.Count;
-                // For reference types and nullable value types, we need to check that there are no nulls
-                // present. (This isn't a thread-safe approach, but we don't advertise this is thread-safe.)
-                // We expect the JITter to optimize this test to true/false, so it's effectively conditional
-                // specialization.
-                if (default(T) == null)
-                {
-                    // TODO: Measure whether iterating once to check and then letting the collection copy
-                    // itself is faster or slower than iterating and adding as we go. For large
-                    // collections this will not be great in terms of cache usage... but the optimized
-                    // copy may be significantly faster than doing it one at a time.
-                    foreach (var item in collection)
-                    {
-                        if (item == null)
-                        {
-                            throw new ArgumentException("Sequence contained null element", nameof(values));
-                        }
-                    }
-                }
-                EnsureSize(count + extraCount);
-                collection.CopyTo(array, count);
-                count += extraCount;
-                return;
-            }
-
-            // We *could* check for ICollection<T> as well, but very very few collections implement
-            // ICollection<T> but not ICollection. (HashSet<T> does, for one...)
-
-            // Fall back to a slower path of adding items one at a time.
+            // TODO: Check for ICollection and get the Count, to optimize?
             foreach (T item in values)
             {
                 Add(item);
             }
         }
 
         /// <summary>
-        /// Adds all of the specified values into this collection. This method is present to
-        /// allow repeated fields to be constructed from queries within collection initializers.
-        /// Within non-collection-initializer code, consider using the equivalent <see cref="AddRange"/>
-        /// method instead for clarity.
-        /// </summary>
-        /// <param name="values">The values to add to this collection.</param>
-        public void Add(IEnumerable<T> values)
-        {
-            AddRange(values);
-        }
-
-        /// <summary>
         /// Returns an enumerator that iterates through the collection.
         /// </summary>
         /// <returns>
         /// An enumerator that can be used to iterate through the collection.
         /// </returns>
         public IEnumerator<T> GetEnumerator()
         {
             for (int i = 0; i < count; i++)
             {
                 yield return array[i];
@@ skipping 70 matching lines @@
         }
 
         /// <summary>
         /// Returns the index of the given item within the collection, or -1 if the item is not
         /// present.
         /// </summary>
         /// <param name="item">The item to find in the collection.</param>
         /// <returns>The zero-based index of the item, or -1 if it is not found.</returns>
         public int IndexOf(T item)
         {
-            ProtoPreconditions.CheckNotNullUnconstrained(item, nameof(item));
+            if (item == null)
+            {
+                throw new ArgumentNullException("item");
+            }
             EqualityComparer<T> comparer = EqualityComparer<T>.Default;
             for (int i = 0; i < count; i++)
             {
                 if (comparer.Equals(array[i], item))
                 {
                     return i;
                 }
             }
             return -1;
         }
 
         /// <summary>
         /// Inserts the given item at the specified index.
         /// </summary>
         /// <param name="index">The index at which to insert the item.</param>
         /// <param name="item">The item to insert.</param>
         public void Insert(int index, T item)
         {
-            ProtoPreconditions.CheckNotNullUnconstrained(item, nameof(item));
+            if (item == null)
+            {
+                throw new ArgumentNullException("item");
+            }
             if (index < 0 || index > count)
             {
-                throw new ArgumentOutOfRangeException(nameof(index));
+                throw new ArgumentOutOfRangeException("index");
             }
             EnsureSize(count + 1);
             Array.Copy(array, index, array, index + 1, count - index);
             array[index] = item;
             count++;
         }
 
         /// <summary>
         /// Removes the item at the given index.
         /// </summary>
         /// <param name="index">The zero-based index of the item to remove.</param>
         public void RemoveAt(int index)
         {
             if (index < 0 || index >= count)
             {
-                throw new ArgumentOutOfRangeException(nameof(index));
+                throw new ArgumentOutOfRangeException("index");
             }
             Array.Copy(array, index + 1, array, index, count - index - 1);
             count--;
             array[count] = default(T);
         }
 
         /// <summary>
         /// Returns a string representation of this repeated field, in the same
         /// way as it would be represented by the default JSON formatter.
         /// </summary>
@@ skipping 11 matching lines @@
         /// The element at the specified index.
         /// </value>
         /// <param name="index">The zero-based index of the element to get or set.</param>
         /// <returns>The item at the specified index.</returns>
         public T this[int index]
         {
             get
             {
                 if (index < 0 || index >= count)
                 {
-                    throw new ArgumentOutOfRangeException(nameof(index));
+                    throw new ArgumentOutOfRangeException("index");
                 }
                 return array[index];
             }
             set
             {
                 if (index < 0 || index >= count)
                 {
-                    throw new ArgumentOutOfRangeException(nameof(index));
+                    throw new ArgumentOutOfRangeException("index");
                 }
-                ProtoPreconditions.CheckNotNullUnconstrained(value, nameof(value));
+                if (value == null)
+                {
+                    throw new ArgumentNullException("value");
+                }
                 array[index] = value;
             }
         }
 
         #region Explicit interface implementation for IList and ICollection.
-        bool IList.IsFixedSize => false;
+        bool IList.IsFixedSize { get { return false; } }
 
         void ICollection.CopyTo(Array array, int index)
         {
             Array.Copy(this.array, 0, array, index, count);
         }
 
-        bool ICollection.IsSynchronized => false;
+        bool ICollection.IsSynchronized { get { return false; } }
 
-        object ICollection.SyncRoot => this;
+        object ICollection.SyncRoot { get { return this; } }
 
         object IList.this[int index]
         {
             get { return this[index]; }
             set { this[index] = (T)value; }
         }
 
         int IList.Add(object value)
         {
             Add((T) value);
@@ skipping 23 matching lines @@
         {
             if (!(value is T))
             {
                 return;
             }
             Remove((T)value);
         }
         #endregion        
     }
 }