Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

mcs/class/System.ServiceModel/System.Collections.Generic/ChangeLog

@@ -0,0 +1,4 @@
+2006-07-13 Ankit Jain  <jankit@novell.com>
+
+	* KeyedByTypeCollection.cs (.ctor): Add IEnumerable<> overload.
+

mcs/class/System.ServiceModel/System.Collections.Generic/KeyedByTypeCollection.cs

@@ -0,0 +1,93 @@
+//
+// KeyedByTypeCollection.cs
+//
+// Author:
+//	Atsushi Enomoto <atsushi@ximian.com>
+//
+// Copyright (C) 2005 Novell, Inc.  http://www.novell.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+using System;
+using System.Collections.ObjectModel;
+
+namespace System.Collections.Generic
+{
+	public class KeyedByTypeCollection<TItem>
+		: KeyedCollection<Type, TItem>
+	{
+		public KeyedByTypeCollection ()
+		{
+		}
+
+		public KeyedByTypeCollection (IEnumerable<TItem> items)
+		{
+			foreach (TItem item in items)
+				Add (item);
+		}
+
+		protected override Type GetKeyForItem (TItem item)
+		{
+			return item.GetType ();
+		}
+
+		public T Find<T> ()
+		{
+			foreach (TItem k in this)
+				if (k is T)
+					return (T) (object) k;
+			return default (T);
+		}
+
+		public Collection<T> FindAll<T> ()
+		{
+			Collection<T> list = new Collection<T> ();
+			foreach (TItem k in this)
+				if (k is T)
+					list.Add ((T) (object) k);
+			return list;
+		}
+
+		protected override void InsertItem (int index, TItem kind)
+		{
+			base.InsertItem (index, kind);
+		}
+
+		protected override void SetItem (int index, TItem kind)
+		{
+			base.SetItem (index, kind);
+		}
+
+		public T Remove<T> ()
+		{
+			foreach (TItem k in this)
+				if (k is T) {
+					Remove (k);
+					return (T) (object) k;
+				}
+			return default (T);
+		}
+
+		public Collection<T> RemoveAll<T> ()
+		{
+			return RemoveAll<T> ();
+		}
+	}
+}

mcs/class/System.ServiceModel/System.Collections.Generic/SynchronizedCollection.cs

@@ -0,0 +1,260 @@
+//
+// SynchronizedCollection.cs
+//
+// Author:
+//	Atsushi Enomoto <atsushi@ximian.com>
+//
+// Copyright (C) 2005 Novell, Inc.  http://www.novell.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Runtime.InteropServices;
+
+namespace System.Collections.Generic
+{
+	[ComVisibleAttribute (false)] 
+	public class SynchronizedCollection<T> : IList<T>, ICollection<T>, 
+		IEnumerable<T>, IList, ICollection, IEnumerable
+	{
+		object root;
+		List<T> list;
+
+		public SynchronizedCollection ()
+			: this (new object (), null, false)
+		{
+		}
+
+		public SynchronizedCollection (object syncRoot)
+			: this (syncRoot, null, false)
+		{
+		}
+
+		public SynchronizedCollection (object syncRoot,
+			IEnumerable<T> list)
+			: this (syncRoot, new List<T> (list), false)
+		{
+		}
+
+		public SynchronizedCollection (object syncRoot,
+			params T [] list)
+			: this (syncRoot, new List<T> (list), false)
+		{
+		}
+
+		public SynchronizedCollection (object syncRoot,
+			List<T> list, bool makeCopy)
+		{
+			if (syncRoot == null)
+				syncRoot = new object ();
+			root = syncRoot;
+			if (list == null)
+				this.list = new List<T> ();
+			else if (makeCopy)
+				this.list = new List<T> (list);
+			else
+				this.list = list;
+		}
+
+		public int Count {
+			get {
+				lock (root) {
+					return list.Count;
+				}
+			}
+		}
+
+		public T this [int index] {
+			get {
+				lock (root) {
+					return list [index];
+				}
+			}
+			set {
+				SetItem (index, value);
+			}
+		}
+
+		public object SyncRoot {
+			get { return root; }
+		}
+
+		protected List<T> Items {
+			get { return list; }
+		}
+
+		public void Add (T item)
+		{
+			InsertItem (list.Count, item);
+		}
+
+		public void Clear ()
+		{
+			ClearItems ();
+		}
+
+		public bool Contains (T item)
+		{
+			lock (root) {
+				return list.Contains (item);
+			}
+		}
+
+		public void CopyTo (T [] array, int index)
+		{
+			lock (root) {
+				list.CopyTo (array, index);
+			}
+		}
+
+		[MonoTODO ("Should be synchronized enumerator?")]
+		public IEnumerator<T> GetEnumerator ()
+		{
+			lock (root) {
+				return list.GetEnumerator ();
+			}
+		}
+
+		public int IndexOf (T item)
+		{
+			lock (root) {
+				return list.IndexOf (item);
+			}
+		}
+
+		public void Insert (int index, T item)
+		{
+			InsertItem (index, item);
+		}
+
+		[MonoTODO ("should we lock and remove item without invoking RemoveItem() instead?")]
+		public bool Remove (T item)
+		{
+			int index = IndexOf (item);
+			if (index < 0)
+				return false;
+			RemoveAt (index);
+			return true;
+		}
+
+		public void RemoveAt (int index)
+		{
+			RemoveItem (index);
+		}
+
+		protected virtual void ClearItems ()
+		{
+			lock (root) {
+				list.Clear ();
+			}
+		}
+
+		protected virtual void InsertItem (int index, T item)
+		{
+			lock (root) {
+				list.Insert (index, item);
+			}
+		}
+
+		protected virtual void RemoveItem (int index)
+		{
+			lock (root) {
+				list.RemoveAt (index);
+			}
+		}
+
+		protected virtual void SetItem (int index, T item)
+		{
+			lock (root) {
+				list [index] = item;
+			}
+		}
+
+		#region Explicit interface implementations
+
+		void ICollection.CopyTo (Array array, int index)
+		{
+			CopyTo ((T []) array, index);
+		}
+
+		IEnumerator IEnumerable.GetEnumerator ()
+		{
+			return GetEnumerator ();
+		}
+
+		int IList.Add (object value)
+		{
+			lock (root) {
+				Add ((T) value);
+				return list.Count - 1;
+			}
+		}
+
+		bool IList.Contains (object value)
+		{
+			return Contains ((T) value);
+		}
+
+		int IList.IndexOf (object value)
+		{
+			return IndexOf ((T) value);
+		}
+
+		void IList.Insert (int index, object value)
+		{
+			Insert (index, (T) value);
+		}
+
+		void IList.Remove (object value)
+		{
+			Remove ((T) value);
+		}
+
+		bool ICollection<T>.IsReadOnly {
+			get { return false; }
+		}
+
+		bool ICollection.IsSynchronized {
+			get { return true; }
+		}
+
+		object ICollection.SyncRoot {
+			get { return root; }
+		}
+
+		bool IList.IsFixedSize {
+			get { return false; }
+		}
+
+		bool IList.IsReadOnly {
+			get { return false; }
+		}
+
+		object IList.this [int index] {
+			get { return this [index]; }
+			set { this [index] = (T) value; }
+		}
+
+		#endregion
+	}
+}

mcs/class/System.ServiceModel/System.Collections.Generic/SynchronizedKeyedCollection.cs

@@ -0,0 +1,142 @@
+//
+// SynchronizedKeyedCollection.cs
+//
+// Author:
+//	Atsushi Enomoto <atsushi@ximian.com>
+//
+// Copyright (C) 2005 Novell, Inc.  http://www.novell.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.ServiceModel.Channels;
+
+namespace System.Collections.Generic
+{
+	[ComVisibleAttribute (false)] 
+	public abstract class SynchronizedKeyedCollection<K, T>
+		: SynchronizedCollection<T>
+	{
+		Dictionary<K, T> dict;
+
+		protected SynchronizedKeyedCollection ()
+			: this (new object ())
+		{
+		}
+
+		protected SynchronizedKeyedCollection (object syncRoot)
+			: base (syncRoot)
+		{
+			dict = new Dictionary<K, T> ();
+		}
+
+		protected SynchronizedKeyedCollection (object syncRoot,
+			IEqualityComparer<K> comparer)
+			: base (syncRoot)
+		{
+			dict = new Dictionary<K, T> (comparer);
+		}
+
+		protected SynchronizedKeyedCollection (object syncRoot,
+			IEqualityComparer<K> comparer, int capacity)
+			: base (syncRoot)
+		{
+			dict = new Dictionary<K, T> (capacity, comparer);
+		}
+
+		// see bug #76417
+		/*
+		public T this [int index] {
+			get { return base [index]; }
+			set { base [index] = value; }
+		}
+		*/
+
+		public T this [K key] {
+			get {
+				lock (SyncRoot) {
+					return dict [key];
+				}
+			}
+		}
+
+		protected IDictionary<K, T> Dictionary {
+			get { return dict; }
+		}
+
+		public bool Contains (K key)
+		{
+			lock (SyncRoot) {
+				return dict.ContainsKey (key);
+			}
+		}
+
+		public bool Remove (K key)
+		{
+			lock (SyncRoot) {
+				return dict.Remove (key);
+			}
+		}
+
+		protected void ChangeItemKey (T item, K newKey)
+		{
+			lock (SyncRoot) {
+				K old = GetKeyForItem (item);
+				dict [old] = default (T);
+				dict [newKey] = item;
+			}
+		}
+
+		[MonoTODO ("This lock is not an atomic.")]
+		protected override void ClearItems ()
+		{
+			base.ClearItems ();
+			lock (SyncRoot) {
+				dict.Clear ();
+			}
+		}
+
+		protected abstract K GetKeyForItem (T item);
+
+		[MonoTODO ("This lock is not an atomic.")]
+		protected override void InsertItem (int index, T item)
+		{
+			base.InsertItem (index, item);
+			dict.Add (GetKeyForItem (item), item);
+		}
+
+		[MonoTODO ("This lock is not an atomic.")]
+		protected override void RemoveItem (int index)
+		{
+			K key = GetKeyForItem (base [index]);
+			base.RemoveItem (index);
+			dict.Remove (key);
+		}
+
+		[MonoTODO ("This lock is not an atomic.")]
+		protected override void SetItem (int index, T item)
+		{
+			base.SetItem (index, item);
+			dict [GetKeyForItem (item)] = item;
+		}
+	}
+}

mcs/class/System.ServiceModel/System.Collections.Generic/SynchronizedReadOnlyCollection.cs

@@ -0,0 +1,223 @@
+//
+// System.ServiceModel.SynchronizedReadOnlyCollection.cs
+//
+// Author: Duncan Mak (duncan@novell.com)
+//
+// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Collections;
+using System.Runtime.InteropServices;
+
+namespace System.Collections.Generic
+{
+	[ComVisible (false)]
+	public class SynchronizedReadOnlyCollection<T>
+		: IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable
+	{
+		List<T> l;
+		object sync_root;
+
+		public SynchronizedReadOnlyCollection ()
+			: this (new object ())
+		{
+		}
+
+		public SynchronizedReadOnlyCollection (object sync_root)
+			: this (sync_root, new List<T> ())
+		{
+		}
+
+		public SynchronizedReadOnlyCollection (object sync_root, IEnumerable<T> list)
+		{
+			if (sync_root == null)
+				throw new ArgumentNullException ("sync_root");
+
+			if (list == null)
+				throw new ArgumentNullException ("list");
+
+			this.sync_root = sync_root;
+			this.l = new List<T> (list);
+		}
+
+		public SynchronizedReadOnlyCollection (object sync_root, params T [] list)
+			: this (sync_root, (IEnumerable<T>) list)
+		{
+		}
+
+		public SynchronizedReadOnlyCollection (object sync_root, List<T> list, bool make_copy)
+			: this (sync_root,
+				list == null ? null : make_copy ? new List<T> (list) : list)
+		{
+		}
+
+		public bool Contains (T value)
+		{
+			bool retval;
+
+			lock (sync_root) {
+				retval = l.Contains (value);
+			}
+
+			return retval;
+		}
+
+		public void CopyTo (T [] array, int index)
+		{
+			lock (sync_root) {
+				l.CopyTo (array, index);
+			}
+		}
+
+		public IEnumerator<T> GetEnumerator ()
+		{
+			IEnumerator<T> retval;
+
+			lock (sync_root) {
+				retval = l.GetEnumerator ();
+			}
+
+			return retval;
+		}
+
+		public int IndexOf (T value)
+		{
+			int retval;
+
+			lock (sync_root) {
+				retval = l.IndexOf (value);
+			}
+
+			return retval;
+		}
+
+		void ICollection<T>.Add (T value) { throw new NotSupportedException (); }
+		void ICollection<T>.Clear () { throw new NotSupportedException (); }
+		bool ICollection<T>.Remove (T value) { throw new NotSupportedException (); }
+
+		void IList<T>.Insert (int index, T value) { throw new NotSupportedException (); }
+		void IList<T>.RemoveAt (int index) { throw new NotSupportedException (); }
+
+		void ICollection.CopyTo (Array array, int index)
+		{
+			ICollection<T> a = array as ICollection<T>;
+
+			if (a == null)
+				throw new ArgumentException ("The array type is not compatible.");
+
+			lock (sync_root) {
+				((ICollection) l).CopyTo (array, index);
+			}
+		}
+
+		IEnumerator IEnumerable.GetEnumerator ()
+		{
+			return GetEnumerator ();
+		}
+
+		int IList.Add (object value) { throw new NotSupportedException (); }
+		void IList.Clear () { throw new NotSupportedException (); }
+
+		bool IList.Contains (object value)
+		{
+			if (typeof (T).IsValueType)
+				throw new ArgumentException ("This is a collection of ValueTypes.");
+
+			// null always gets thru
+			if (value is T == false && value != null)
+				throw new ArgumentException ("value is not of the same type as this collection.");
+
+			bool retval;
+			T val = (T) value;
+			lock (sync_root) {
+				retval = l.Contains (val);
+			}
+
+			return retval;
+		}
+
+		int IList.IndexOf (object value)
+		{
+			if (typeof (T).IsValueType)
+				throw new ArgumentException ("This is a collection of ValueTypes.");
+
+			if (value is T == false)
+				throw new ArgumentException ("value is not of the same type as this collection.");
+
+			int retval;
+			T val = (T) value;
+			lock (sync_root) {
+				retval = l.IndexOf (val);
+			}
+
+			return retval;
+		}
+
+		void IList.Insert (int index, object value) { throw new NotSupportedException (); }
+		void IList.Remove (object value) { throw new NotSupportedException (); }
+		void IList.RemoveAt (int index) { throw new NotSupportedException (); }
+
+		public int Count {
+			get {
+				int retval;
+				lock (sync_root) {
+					retval = l.Count;
+				}
+				return retval;
+			}
+		}
+
+		public T this [int index] {
+			get {
+				T retval;
+				lock (sync_root) {
+					retval = l [index];
+				}
+				return retval;
+			}
+		}
+
+		protected IList<T> Items {
+			get { return l; }
+		}
+
+
+		bool ICollection<T>.IsReadOnly { get { return true; }}
+
+		bool ICollection.IsSynchronized { get { return true; }}
+		object ICollection.SyncRoot { get { return sync_root; }}
+
+		bool IList.IsFixedSize { get { return true; }}
+		bool IList.IsReadOnly { get { return true; }}
+
+		T IList<T>.this [int index] {
+			get { return this [index]; }
+			set { throw new NotSupportedException (); }
+		}
+
+		object IList.this [int index] {
+			get { return this [index]; }
+			set { throw new NotSupportedException (); }
+		}
+	}
+}