First cut at new layout

1 files changed, 112 insertions, 0 deletions

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();
+    }
+  }
+}