diff options
Diffstat (limited to 'src/ProtocolBuffers/Collections')
-rw-r--r-- | src/ProtocolBuffers/Collections/Dictionaries.cs | 108 | ||||
-rw-r--r-- | src/ProtocolBuffers/Collections/Lists.cs | 56 | ||||
-rw-r--r-- | src/ProtocolBuffers/Collections/PopsicleList.cs | 95 | ||||
-rw-r--r-- | src/ProtocolBuffers/Collections/ReadOnlyDictionary.cs | 112 |
4 files changed, 371 insertions, 0 deletions
diff --git a/src/ProtocolBuffers/Collections/Dictionaries.cs b/src/ProtocolBuffers/Collections/Dictionaries.cs new file mode 100644 index 00000000..5ba02664 --- /dev/null +++ b/src/ProtocolBuffers/Collections/Dictionaries.cs @@ -0,0 +1,108 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections; +using System.Collections.Generic; + +namespace Google.ProtocolBuffers.Collections { + + /// <summary> + /// Non-generic class with generic methods which proxy to the non-generic methods + /// in the generic class. + /// </summary> + public static class Dictionaries { + + /// <summary> + /// Compares two dictionaries for equality. Each value is compared with equality using Equals + /// for non-IEnumerable implementations, and using EnumerableEquals otherwise. + /// TODO(jonskeet): This is clearly pretty slow, and involves lots of boxing/unboxing... + /// </summary> + public static bool Equals<TKey, TValue>(IDictionary<TKey, TValue> left, IDictionary<TKey, TValue> right) { + if (left.Count != right.Count) { + return false; + } + foreach (KeyValuePair<TKey,TValue> leftEntry in left) + { + TValue rightValue; + if (!right.TryGetValue(leftEntry.Key, out rightValue)) { + return false; + } + + IEnumerable leftEnumerable = leftEntry.Value as IEnumerable; + IEnumerable rightEnumerable = rightValue as IEnumerable; + if (leftEnumerable == null || rightEnumerable == null) { + if (!object.Equals(leftEntry.Value, rightValue)) { + return false; + } + } else { + IEnumerator leftEnumerator = leftEnumerable.GetEnumerator(); + try { + foreach (object rightObject in rightEnumerable) { + if (!leftEnumerator.MoveNext()) { + return false; + } + if (!object.Equals(leftEnumerator.Current, rightObject)) { + return false; + } + } + if (leftEnumerator.MoveNext()) { + return false; + } + } finally { + if (leftEnumerator is IDisposable) { + ((IDisposable)leftEnumerator).Dispose(); + } + } + } + } + return true; + } + + public static IDictionary<TKey, TValue> AsReadOnly<TKey, TValue> (IDictionary<TKey, TValue> dictionary) { + return dictionary.IsReadOnly ? dictionary : new ReadOnlyDictionary<TKey, TValue>(dictionary); + } + + /// <summary> + /// Creates a hashcode for a dictionary by XORing the hashcodes of all the fields + /// and values. (By XORing, we avoid ordering issues.) + /// TODO(jonskeet): Currently XORs other stuff too, and assumes non-null values. + /// </summary> + public static int GetHashCode<TKey, TValue>(IDictionary<TKey, TValue> dictionary) { + int ret = 31; + foreach (KeyValuePair<TKey, TValue> entry in dictionary) { + int hash = entry.Key.GetHashCode() ^ GetDeepHashCode(entry.Value); + ret ^= hash; + } + return ret; + } + + /// <summary> + /// Determines the hash of a value by either taking it directly or hashing all the elements + /// for IEnumerable implementations. + /// </summary> + private static int GetDeepHashCode(object value) { + IEnumerable iterable = value as IEnumerable; + if (iterable == null) { + return value.GetHashCode(); + } + int hash = 29; + foreach (object element in iterable) { + hash = hash * 37 + element.GetHashCode(); + } + return hash; + } + } +} diff --git a/src/ProtocolBuffers/Collections/Lists.cs b/src/ProtocolBuffers/Collections/Lists.cs new file mode 100644 index 00000000..b1b6b122 --- /dev/null +++ b/src/ProtocolBuffers/Collections/Lists.cs @@ -0,0 +1,56 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.Collections.Generic; +using System.Collections.ObjectModel; + +namespace Google.ProtocolBuffers.Collections { + + /// <summary> + /// Utility non-generic class for calling into Lists{T} using type inference. + /// </summary> + public static class Lists { + + /// <summary> + /// Returns a read-only view of the specified list. + /// </summary> + public static IList<T> AsReadOnly<T>(IList<T> list) { + return Lists<T>.AsReadOnly(list); + } + } + + /// <summary> + /// Utility class for dealing with lists. + /// </summary> + public static class Lists<T> { + + static readonly ReadOnlyCollection<T> empty = new ReadOnlyCollection<T>(new T[0]); + + /// <summary> + /// Returns an immutable empty list. + /// </summary> + public static ReadOnlyCollection<T> Empty { + get { return empty; } + } + + /// <summary> + /// Returns either the original reference if it's already read-only, + /// or a new ReadOnlyCollection wrapping the original list. + /// </summary> + public static IList<T> AsReadOnly(IList<T> list) { + return list.IsReadOnly ? list : new ReadOnlyCollection<T>(list); + } + } +} diff --git a/src/ProtocolBuffers/Collections/PopsicleList.cs b/src/ProtocolBuffers/Collections/PopsicleList.cs new file mode 100644 index 00000000..4efe13d0 --- /dev/null +++ b/src/ProtocolBuffers/Collections/PopsicleList.cs @@ -0,0 +1,95 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Collections; + +namespace Google.ProtocolBuffers.Collections { + /// <summary> + /// Proxies calls to a <see cref="List{T}" />, but allows the list + /// to be made read-only (with the <see cref="MakeReadOnly" /> method), + /// after which any modifying methods throw <see cref="NotSupportedException" />. + /// </summary> + public sealed class PopsicleList<T> : IList<T> { + + private readonly List<T> items = new List<T>(); + private bool readOnly = false; + + /// <summary> + /// Makes this list read-only ("freezes the popsicle"). From this + /// point on, mutating methods (Clear, Add etc) will throw a + /// NotSupportedException. There is no way of "defrosting" the list afterwards. + /// </summary> + public void MakeReadOnly() { + readOnly = true; + } + + public int IndexOf(T item) { + return items.IndexOf(item); + } + + public void Insert(int index, T item) { + ValidateModification(); + items.Insert(index, item); + } + + public void RemoveAt(int index) { + ValidateModification(); + items.RemoveAt(index); + } + + public T this[int index] { + get { + return items[index]; + } + set { + ValidateModification(); + items[index] = value; + } + } + + public void Add(T item) { + ValidateModification(); + items.Add(item); + } + + public void Clear() { + ValidateModification(); + items.Clear(); + } + + public bool Contains(T item) { + return items.Contains(item); + } + + public void CopyTo(T[] array, int arrayIndex) { + items.CopyTo(array, arrayIndex); + } + + public int Count { + get { return items.Count; } + } + + public bool IsReadOnly { + get { return readOnly; } + } + + public bool Remove(T item) { + ValidateModification(); + return items.Remove(item); + } + + public IEnumerator<T> GetEnumerator() { + return items.GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() { + return GetEnumerator(); + } + + private void ValidateModification() { + if (readOnly) { + throw new NotSupportedException("List is read-only"); + } + } + } +} diff --git a/src/ProtocolBuffers/Collections/ReadOnlyDictionary.cs b/src/ProtocolBuffers/Collections/ReadOnlyDictionary.cs new file mode 100644 index 00000000..cd4b1898 --- /dev/null +++ b/src/ProtocolBuffers/Collections/ReadOnlyDictionary.cs @@ -0,0 +1,112 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections; +using System.Collections.Generic; + +namespace Google.ProtocolBuffers.Collections { + /// <summary> + /// Read-only wrapper around another dictionary. + /// </summary> + public sealed class ReadOnlyDictionary<TKey, TValue> : IDictionary<TKey, TValue> { + readonly IDictionary<TKey, TValue> wrapped; + + public ReadOnlyDictionary(IDictionary<TKey, TValue> wrapped) { + this.wrapped = wrapped; + } + + public void Add(TKey key, TValue value) { + throw new InvalidOperationException(); + } + + public bool ContainsKey(TKey key) { + return wrapped.ContainsKey(key); + } + + public ICollection<TKey> Keys { + get { return wrapped.Keys; } + } + + public bool Remove(TKey key) { + throw new InvalidOperationException(); + } + + public bool TryGetValue(TKey key, out TValue value) { + return wrapped.TryGetValue(key, out value); + } + + public ICollection<TValue> Values { + get { return wrapped.Values; } + } + + public TValue this[TKey key] { + get { + return wrapped[key]; + } + set { + throw new InvalidOperationException(); + } + } + + public void Add(KeyValuePair<TKey, TValue> item) { + throw new InvalidOperationException(); + } + + public void Clear() { + throw new InvalidOperationException(); + } + + public bool Contains(KeyValuePair<TKey, TValue> item) { + return wrapped.Contains(item); + } + + public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex) { + wrapped.CopyTo(array, arrayIndex); + } + + public int Count { + get { return wrapped.Count; } + } + + public bool IsReadOnly { + get { return true; } + } + + public bool Remove(KeyValuePair<TKey, TValue> item) { + throw new InvalidOperationException(); + } + + public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() { + return wrapped.GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() { + return ((IEnumerable) wrapped).GetEnumerator(); + } + + public override bool Equals(object obj) { + return wrapped.Equals(obj); + } + + public override int GetHashCode() { + return wrapped.GetHashCode(); + } + + public override string ToString() { + return wrapped.ToString(); + } + } +} |