Files
mono/mcs/class/corlib/System.Collections.Generic/Dictionary.cs
T
Sebastien Pouliot aa4096bfbf 2007-11-05 Sebastien Pouliot <[email protected]>
* Dictionary.cs: Ensure that the non-generic CopyTo works on Array.
	Fix #322783


svn path=/trunk/mcs/; revision=88940
2007-11-05 23:51:42 +00:00

1115 lines
29 KiB
C#

//
// System.Collections.Generic.Dictionary
//
// Authors:
// Sureshkumar T ([email protected])
// Marek Safar ([email protected]) (stubs)
// Ankit Jain ([email protected])
// David Waite ([email protected])
// Juraj Skripsky ([email protected])
//
//
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
// Copyright (C) 2005 David Waite
// Copyright (C) 2007 HotFeet GmbH (http://www.hotfeet.ch)
//
// 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.
//
#if NET_2_0
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Security.Permissions;
using System.Runtime.InteropServices;
namespace System.Collections.Generic {
[ComVisible(false)]
[Serializable]
public class Dictionary<TKey, TValue> : IDictionary<TKey, TValue>,
IDictionary,
ICollection,
ICollection<KeyValuePair<TKey, TValue>>,
IEnumerable<KeyValuePair<TKey, TValue>>,
ISerializable,
IDeserializationCallback
{
// The implementation of this class uses a hash table and linked lists
// (see: http://msdn2.microsoft.com/en-us/library/ms379571(VS.80).aspx).
//
// We use a kind of "mini-heap" instead of reference-based linked lists:
// "keySlots" and "valueSlots" is the heap itself, it stores the data
// "linkSlots" contains information about how the slots in the heap
// are connected into linked lists
// "touchedSlots" and "emptySlot" manage the free space in the heap
const int INITIAL_SIZE = 10;
const float DEFAULT_LOAD_FACTOR = (90f / 100);
const int NO_SLOT = -1;
private struct Link {
public int HashCode;
public int Next;
}
// The hash table contains indices into the linkSlots array
int [] table;
// All (key,value) pairs are chained into linked lists. The connection
// information is stored in "linkSlots" along with the key's hash code
// (for performance reasons).
// TODO: get rid of the hash code in Link (this depends on a few
// JIT-compiler optimizations)
// Every link in "linkSlots" corresponds to the (key,value) pair
// in "keySlots"/"valueSlots" with the same index.
Link [] linkSlots;
TKey [] keySlots;
TValue [] valueSlots;
// The number of slots in "linkSlots" and "keySlots"/"valueSlots" that
// are in use (i.e. filled with data) or have been used and marked as
// "empty" later on.
int touchedSlots;
// The index of the first slot in the "empty slots chain".
// "Remove()" prepends the cleared slots to the empty chain.
// "Add()" fills the first slot in the empty slots chain with the
// added item (or increases "touchedSlots" if the chain itself is empty).
int emptySlot;
// The number of (key,value) pairs in this dictionary.
int count;
// The number of (key,value) pairs the dictionary can hold without
// resizing the hash table and the slots arrays.
int threshold;
IEqualityComparer<TKey> hcp;
SerializationInfo serialization_info;
// The number of changes made to this dictionary. Used by enumerators
// to detect changes and invalidate themselves.
int generation;
public int Count {
get { return count; }
}
public TValue this [TKey key] {
get {
if (key == null)
throw new ArgumentNullException ("key");
// get first item of linked list corresponding to given key
int hashCode = hcp.GetHashCode (key);
int cur = table [(hashCode & int.MaxValue) % table.Length] - 1;
// walk linked list until right slot is found or end is reached
while (cur != NO_SLOT) {
// The ordering is important for compatibility with MS and strange
// Object.Equals () implementations
if (linkSlots [cur].HashCode == hashCode && hcp.Equals (keySlots [cur], key))
return valueSlots [cur];
cur = linkSlots [cur].Next;
}
throw new KeyNotFoundException ();
}
set {
if (key == null)
throw new ArgumentNullException ("key");
// get first item of linked list corresponding to given key
int hashCode = hcp.GetHashCode (key);
int index = (hashCode & int.MaxValue) % table.Length;
int cur = table [index] - 1;
// walk linked list until right slot (and its predecessor) is
// found or end is reached
int prev = NO_SLOT;
if (cur != NO_SLOT) {
do {
// The ordering is important for compatibility with MS and strange
// Object.Equals () implementations
if (linkSlots [cur].HashCode == hashCode && hcp.Equals (keySlots [cur], key))
break;
prev = cur;
cur = linkSlots [cur].Next;
} while (cur != NO_SLOT);
}
// is there no slot for the given key yet?
if (cur == NO_SLOT) {
// there is no existing slot for the given key,
// allocate one and prepend it to its corresponding linked
// list
if (++count > threshold) {
Resize ();
index = (hashCode & int.MaxValue) % table.Length;
}
// find an empty slot
cur = emptySlot;
if (cur == NO_SLOT)
cur = touchedSlots++;
else
emptySlot = linkSlots [cur].Next;
// prepend the added item to its linked list,
// update the hash table
linkSlots [cur].Next = table [index] - 1;
table [index] = cur + 1;
} else {
// we already have a slot for the given key,
// update the existing slot
// if the slot is not at the front of its linked list,
// we move it there
if (prev != NO_SLOT) {
linkSlots [prev].Next = linkSlots [cur].Next;
linkSlots [cur].Next = table [index] - 1;
table [index] = cur + 1;
}
}
// store the hash code of the new item and
// the item's data itself
linkSlots [cur].HashCode = hashCode;
keySlots [cur] = key;
valueSlots [cur] = value;
generation++;
}
}
public Dictionary ()
{
Init (INITIAL_SIZE, null);
}
public Dictionary (IEqualityComparer<TKey> comparer)
{
Init (INITIAL_SIZE, comparer);
}
public Dictionary (IDictionary<TKey, TValue> dictionary)
: this (dictionary, null)
{
}
public Dictionary (int capacity)
{
Init (capacity, null);
}
public Dictionary (IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey> comparer)
{
if (dictionary == null)
throw new ArgumentNullException ("dictionary");
int capacity = dictionary.Count;
Init (capacity, comparer);
foreach (KeyValuePair<TKey, TValue> entry in dictionary)
this.Add (entry.Key, entry.Value);
}
public Dictionary (int capacity, IEqualityComparer<TKey> comparer)
{
Init (capacity, comparer);
}
protected Dictionary (SerializationInfo info, StreamingContext context)
{
serialization_info = info;
}
private void Init (int capacity, IEqualityComparer<TKey> hcp)
{
if (capacity < 0)
throw new ArgumentOutOfRangeException ("capacity");
this.hcp = (hcp != null) ? hcp : EqualityComparer<TKey>.Default;
if (capacity == 0)
capacity = INITIAL_SIZE;
/* Modify capacity so 'capacity' elements can be added without resizing */
capacity = (int)(capacity / DEFAULT_LOAD_FACTOR) + 1;
InitArrays (capacity);
generation = 0;
}
private void InitArrays (int size) {
table = new int [size];
linkSlots = new Link [size];
emptySlot = NO_SLOT;
keySlots = new TKey [size];
valueSlots = new TValue [size];
touchedSlots = 0;
threshold = (int)(table.Length * DEFAULT_LOAD_FACTOR);
if (threshold == 0 && table.Length > 0)
threshold = 1;
}
void CopyTo (KeyValuePair<TKey, TValue> [] array, int index)
{
if (array == null)
throw new ArgumentNullException ("array");
if (index < 0)
throw new ArgumentOutOfRangeException ("index");
// we want no exception for index==array.Length && Count == 0
if (index > array.Length)
throw new ArgumentException ("index larger than largest valid index of array");
if (array.Length - index < Count)
throw new ArgumentException ("Destination array cannot hold the requested elements!");
for (int i = 0; i < table.Length; i++) {
int cur = table [i] - 1;
while (cur != NO_SLOT) {
array [index++] = new KeyValuePair<TKey, TValue> (keySlots [cur], valueSlots [cur]);
cur = linkSlots [cur].Next;
}
}
}
private void Resize ()
{
// From the SDK docs:
// Hashtable is automatically increased
// to the smallest prime number that is larger
// than twice the current number of Hashtable buckets
int newSize = Hashtable.ToPrime ((table.Length << 1) | 1);
// allocate new hash table and link slots array
int [] newTable = new int [newSize];
Link [] newLinkSlots = new Link [newSize];
for (int i = 0; i < table.Length; i++) {
int cur = table [i] - 1;
while (cur != NO_SLOT) {
int hashCode = newLinkSlots [cur].HashCode = hcp.GetHashCode(keySlots [cur]);
int index = (hashCode & int.MaxValue) % newSize;
newLinkSlots [cur].Next = newTable [index] - 1;
newTable [index] = cur + 1;
cur = linkSlots [cur].Next;
}
}
table = newTable;
linkSlots = newLinkSlots;
// allocate new data slots, copy data
TKey [] newKeySlots = new TKey [newSize];
TValue [] newValueSlots = new TValue [newSize];
Array.Copy (keySlots, 0, newKeySlots, 0, touchedSlots);
Array.Copy (valueSlots, 0, newValueSlots, 0, touchedSlots);
keySlots = newKeySlots;
valueSlots = newValueSlots;
threshold = (int)(newSize * DEFAULT_LOAD_FACTOR);
}
public void Add (TKey key, TValue value)
{
if (key == null)
throw new ArgumentNullException ("key");
// get first item of linked list corresponding to given key
int hashCode = hcp.GetHashCode (key);
int index = (hashCode & int.MaxValue) % table.Length;
int cur = table [index] - 1;
// walk linked list until end is reached (throw an exception if a
// existing slot is found having an equivalent key)
while (cur != NO_SLOT) {
// The ordering is important for compatibility with MS and strange
// Object.Equals () implementations
if (linkSlots [cur].HashCode == hashCode && hcp.Equals (keySlots [cur], key))
throw new ArgumentException ("An element with the same key already exists in the dictionary.");
cur = linkSlots [cur].Next;
}
if (++count > threshold) {
Resize ();
index = (hashCode & int.MaxValue) % table.Length;
}
// find an empty slot
cur = emptySlot;
if (cur == NO_SLOT)
cur = touchedSlots++;
else
emptySlot = linkSlots [cur].Next;
// store the hash code of the added item,
// prepend the added item to its linked list,
// update the hash table
linkSlots [cur].HashCode = hashCode;
linkSlots [cur].Next = table [index] - 1;
table [index] = cur + 1;
// store item's data
keySlots [cur] = key;
valueSlots [cur] = value;
generation++;
}
public IEqualityComparer<TKey> Comparer {
get { return hcp; }
}
public void Clear ()
{
count = 0;
// clear the hash table
Array.Clear(table, 0, table.Length);
// empty the "empty slots chain"
emptySlot = NO_SLOT;
touchedSlots = 0;
generation++;
}
public bool ContainsKey (TKey key)
{
// get first item of linked list corresponding to given key
int hashCode = hcp.GetHashCode (key);
int cur = table [(hashCode & int.MaxValue) % table.Length] - 1;
// walk linked list until right slot is found or end is reached
while (cur != NO_SLOT) {
// The ordering is important for compatibility with MS and strange
// Object.Equals () implementations
if (linkSlots [cur].HashCode == hashCode && hcp.Equals (keySlots [cur], key))
return true;
cur = linkSlots [cur].Next;
}
return false;
}
public bool ContainsValue (TValue value)
{
IEqualityComparer<TValue> cmp = EqualityComparer<TValue>.Default;
for (int i = 0; i < table.Length; i++) {
int cur = table [i] - 1;
while (cur != NO_SLOT) {
if (cmp.Equals (valueSlots [cur], value))
return true;
cur = linkSlots [cur].Next;
}
}
return false;
}
[SecurityPermission (SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.SerializationFormatter)]
public virtual void GetObjectData (SerializationInfo info, StreamingContext context)
{
if (info == null)
throw new ArgumentNullException ("info");
info.AddValue ("Version", generation);
info.AddValue ("Comparer", hcp);
KeyValuePair<TKey, TValue> [] data = null;
if (count > 0) {
data = new KeyValuePair<TKey,TValue> [count];
CopyTo (data, 0);
}
info.AddValue ("HashSize", table.Length);
info.AddValue ("KeyValuePairs", data);
}
public virtual void OnDeserialization (object sender)
{
if (serialization_info == null)
return;
generation = serialization_info.GetInt32 ("Version");
hcp = (IEqualityComparer<TKey>) serialization_info.GetValue ("Comparer", typeof (IEqualityComparer<TKey>));
int hashSize = serialization_info.GetInt32 ("HashSize");
KeyValuePair<TKey, TValue> [] data =
(KeyValuePair<TKey, TValue> [])
serialization_info.GetValue ("KeyValuePairs", typeof (KeyValuePair<TKey, TValue> []));
if (hashSize < INITIAL_SIZE)
hashSize = INITIAL_SIZE;
InitArrays (hashSize);
count = 0;
if (data != null) {
for (int i = 0; i < data.Length; ++i)
Add (data [i].Key, data [i].Value);
}
generation++;
serialization_info = null;
}
public bool Remove (TKey key)
{
if (key == null)
throw new ArgumentNullException ("key");
// get first item of linked list corresponding to given key
int hashCode = hcp.GetHashCode (key);
int index = (hashCode & int.MaxValue) % table.Length;
int cur = table [index] - 1;
// if there is no linked list, return false
if (cur == NO_SLOT)
return false;
// walk linked list until right slot (and its predecessor) is
// found or end is reached
int prev = NO_SLOT;
do {
// The ordering is important for compatibility with MS and strange
// Object.Equals () implementations
if (linkSlots [cur].HashCode == hashCode && hcp.Equals (keySlots [cur], key))
break;
prev = cur;
cur = linkSlots [cur].Next;
} while (cur != NO_SLOT);
// if we reached the end of the chain, return false
if (cur == NO_SLOT)
return false;
count--;
// remove slot from linked list
// is slot at beginning of linked list?
if (prev == NO_SLOT)
table [index] = linkSlots [cur].Next + 1;
else
linkSlots [prev].Next = linkSlots [cur].Next;
// mark slot as empty and prepend it to "empty slots chain"
linkSlots [cur].Next = emptySlot;
emptySlot = cur;
generation++;
return true;
}
public bool TryGetValue (TKey key, out TValue value)
{
if (key == null)
throw new ArgumentNullException ("key");
// get first item of linked list corresponding to given key
int hashCode = hcp.GetHashCode (key);
int cur = table [(hashCode & int.MaxValue) % table.Length] - 1;
// walk linked list until right slot is found or end is reached
while (cur != NO_SLOT) {
// The ordering is important for compatibility with MS and strange
// Object.Equals () implementations
if (linkSlots [cur].HashCode == hashCode && hcp.Equals (keySlots [cur], key)) {
value = valueSlots [cur];
return true;
}
cur = linkSlots [cur].Next;
}
// we did not find the slot
value = default (TValue);
return false;
}
ICollection<TKey> IDictionary<TKey, TValue>.Keys {
get { return Keys; }
}
ICollection<TValue> IDictionary<TKey, TValue>.Values {
get { return Values; }
}
public KeyCollection Keys {
get { return new KeyCollection (this); }
}
public ValueCollection Values {
get { return new ValueCollection (this); }
}
ICollection IDictionary.Keys {
get { return Keys; }
}
ICollection IDictionary.Values {
get { return Values; }
}
bool IDictionary.IsFixedSize {
get { return false; }
}
bool IDictionary.IsReadOnly {
get { return false; }
}
TKey ToTKey (object key)
{
if (key == null)
throw new ArgumentNullException ("key");
if (!(key is TKey))
throw new ArgumentException ("not of type: " + typeof (TKey).ToString (), "key");
return (TKey) key;
}
TValue ToTValue (object value)
{
if (!(value is TValue))
throw new ArgumentException ("not of type: " + typeof (TValue).ToString (), "value");
return (TValue) value;
}
object IDictionary.this [object key] {
get {
if (key is TKey && ContainsKey((TKey) key))
return this [ToTKey (key)];
return null;
}
set { this [ToTKey (key)] = ToTValue (value); }
}
void IDictionary.Add (object key, object value)
{
this.Add (ToTKey (key), ToTValue (value));
}
bool IDictionary.Contains (object key)
{
if (key == null)
throw new ArgumentNullException ("key");
if (key is TKey)
return ContainsKey ((TKey) key);
return false;
}
void IDictionary.Remove (object key)
{
if (key == null)
throw new ArgumentNullException ("key");
if (key is TKey)
Remove ((TKey) key);
}
bool ICollection.IsSynchronized {
get { return false; }
}
object ICollection.SyncRoot {
get { return this; }
}
bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly {
get { return false; }
}
void ICollection<KeyValuePair<TKey, TValue>>.Add (KeyValuePair<TKey, TValue> keyValuePair)
{
Add (keyValuePair.Key, keyValuePair.Value);
}
bool ICollection<KeyValuePair<TKey, TValue>>.Contains (KeyValuePair<TKey, TValue> keyValuePair)
{
return this.ContainsKey (keyValuePair.Key);
}
void ICollection<KeyValuePair<TKey, TValue>>.CopyTo (KeyValuePair<TKey, TValue> [] array, int index)
{
this.CopyTo (array, index);
}
bool ICollection<KeyValuePair<TKey, TValue>>.Remove (KeyValuePair<TKey, TValue> keyValuePair)
{
return Remove (keyValuePair.Key);
}
void ICollection.CopyTo (Array array, int index)
{
if (array == null)
throw new ArgumentNullException ("array");
if (index < 0)
throw new ArgumentOutOfRangeException ("index");
// we want no exception for index==array.Length && Count == 0
if (index > array.Length)
throw new ArgumentException ("index larger than largest valid index of array");
if (array.Length - index < count)
throw new ArgumentException ("Destination array cannot hold the requested elements!");
for (int i = 0; i < table.Length; i++) {
int cur = table [i] - 1;
while (cur != NO_SLOT) {
array.SetValue (new DictionaryEntry (keySlots [cur], valueSlots [cur]), index++);
cur = linkSlots [cur].Next;
}
}
}
IEnumerator IEnumerable.GetEnumerator ()
{
return new Enumerator (this);
}
IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator ()
{
return new Enumerator (this);
}
IDictionaryEnumerator IDictionary.GetEnumerator ()
{
return new ShimEnumerator (this);
}
public Enumerator GetEnumerator ()
{
return new Enumerator (this);
}
[Serializable]
private class ShimEnumerator : IDictionaryEnumerator, IEnumerator
{
Enumerator host_enumerator;
public ShimEnumerator (Dictionary<TKey, TValue> host)
{
host_enumerator = host.GetEnumerator ();
}
public void Dispose ()
{
host_enumerator.Dispose ();
}
public bool MoveNext ()
{
return host_enumerator.MoveNext ();
}
public DictionaryEntry Entry {
get { return ((IDictionaryEnumerator) host_enumerator).Entry; }
}
public object Key {
get { return host_enumerator.Current.Key; }
}
public object Value {
get { return host_enumerator.Current.Value; }
}
// This is the raison d' etre of this $%!@$%@^@ class.
// We want: IDictionary.GetEnumerator ().Current is DictionaryEntry
public object Current {
get { return Entry; }
}
public void Reset ()
{
((IEnumerator)host_enumerator).Reset ();
}
}
[Serializable]
public struct Enumerator : IEnumerator<KeyValuePair<TKey,TValue>>,
IDisposable, IDictionaryEnumerator, IEnumerator
{
Dictionary<TKey, TValue> dictionary;
int curTableItem;
int cur;
int stamp;
internal Enumerator (Dictionary<TKey, TValue> dictionary)
{
this.dictionary = dictionary;
stamp = dictionary.generation;
// The following stanza is identical to IEnumerator.Reset (),
// but because of the definite assignment rule, we cannot call it here.
curTableItem = -1;
cur = NO_SLOT;
}
public bool MoveNext ()
{
VerifyState ();
do {
if (cur == NO_SLOT) {
//move to next item in table, check if we reached the end
if (curTableItem+1 >= dictionary.table.Length)
return false;
curTableItem++;
cur = dictionary.table [curTableItem] - 1;
} else
cur = dictionary.linkSlots [cur].Next;
} while (cur == NO_SLOT);
return true;
}
public KeyValuePair<TKey, TValue> Current {
get {
VerifyCurrent ();
return new KeyValuePair <TKey, TValue> (
dictionary.keySlots [cur],
dictionary.valueSlots [cur]
);
}
}
internal TKey CurrentKey {
get {
VerifyCurrent ();
return dictionary.keySlots [cur];
}
}
internal TValue CurrentValue {
get {
VerifyCurrent ();
return dictionary.valueSlots [cur];
}
}
object IEnumerator.Current {
get { return Current; }
}
void IEnumerator.Reset ()
{
curTableItem = -1;
cur = NO_SLOT;
}
DictionaryEntry IDictionaryEnumerator.Entry {
get {
VerifyCurrent ();
return new DictionaryEntry (
dictionary.keySlots [cur],
dictionary.valueSlots [cur]
);
}
}
object IDictionaryEnumerator.Key {
get {
VerifyCurrent();
return dictionary.keySlots [cur];
}
}
object IDictionaryEnumerator.Value {
get {
VerifyCurrent();
return dictionary.valueSlots [cur];
}
}
void VerifyState ()
{
if (dictionary == null)
throw new ObjectDisposedException (null);
if (dictionary.generation != stamp)
throw new InvalidOperationException ("out of sync");
}
void VerifyCurrent ()
{
VerifyState ();
if (cur == NO_SLOT)
throw new InvalidOperationException ("Current is not valid");
}
public void Dispose ()
{
dictionary = null;
}
}
// This collection is a read only collection
[Serializable]
public sealed class KeyCollection : ICollection<TKey>, IEnumerable<TKey>, ICollection, IEnumerable {
Dictionary<TKey, TValue> dictionary;
public KeyCollection (Dictionary<TKey, TValue> dictionary)
{
if (dictionary == null)
throw new ArgumentNullException ("dictionary");
this.dictionary = dictionary;
}
void CopyToCheck (IList array, int index)
{
if (array == null)
throw new ArgumentNullException ("array");
if (index < 0)
throw new ArgumentOutOfRangeException ("index");
// we want no exception for index==array.Length && dictionary.Count == 0
if (index > array.Count)
throw new ArgumentException ("index larger than largest valid index of array");
if (array.Count - index < dictionary.Count)
throw new ArgumentException ("Destination array cannot hold the requested elements!");
}
public void CopyTo (TKey [] array, int index)
{
CopyToCheck ((IList)array, index);
for (int i = 0; i < dictionary.table.Length; i++) {
int cur = dictionary.table [i] - 1;
while (cur != NO_SLOT) {
array [index++] = dictionary.keySlots [cur];
cur = dictionary.linkSlots [cur].Next;
}
}
}
public Enumerator GetEnumerator ()
{
return new Enumerator (dictionary);
}
void ICollection<TKey>.Add (TKey item)
{
throw new NotSupportedException ("this is a read-only collection");
}
void ICollection<TKey>.Clear ()
{
throw new NotSupportedException ("this is a read-only collection");
}
bool ICollection<TKey>.Contains (TKey item)
{
return dictionary.ContainsKey (item);
}
bool ICollection<TKey>.Remove (TKey item)
{
throw new NotSupportedException ("this is a read-only collection");
}
IEnumerator<TKey> IEnumerable<TKey>.GetEnumerator ()
{
return this.GetEnumerator ();
}
void ICollection.CopyTo (Array array, int index)
{
IList list = array;
CopyToCheck (list, index);
for (int i = 0; i < dictionary.table.Length; i++) {
int cur = dictionary.table [i] - 1;
while (cur != NO_SLOT) {
list [index++] = dictionary.keySlots [cur];
cur = dictionary.linkSlots [cur].Next;
}
}
}
IEnumerator IEnumerable.GetEnumerator ()
{
return this.GetEnumerator ();
}
public int Count {
get { return dictionary.Count; }
}
bool ICollection<TKey>.IsReadOnly {
get { return true; }
}
bool ICollection.IsSynchronized {
get { return false; }
}
object ICollection.SyncRoot {
get { return ((ICollection) dictionary).SyncRoot; }
}
[Serializable]
public struct Enumerator : IEnumerator<TKey>, IDisposable, IEnumerator {
Dictionary<TKey, TValue>.Enumerator host_enumerator;
internal Enumerator (Dictionary<TKey, TValue> host)
{
host_enumerator = host.GetEnumerator ();
}
public void Dispose ()
{
host_enumerator.Dispose ();
}
public bool MoveNext ()
{
return host_enumerator.MoveNext ();
}
public TKey Current {
get { return host_enumerator.CurrentKey; }
}
object IEnumerator.Current {
get { return host_enumerator.CurrentKey; }
}
void IEnumerator.Reset ()
{
((IEnumerator)host_enumerator).Reset ();
}
}
}
// This collection is a read only collection
[Serializable]
public sealed class ValueCollection : ICollection<TValue>, IEnumerable<TValue>, ICollection, IEnumerable {
Dictionary<TKey, TValue> dictionary;
public ValueCollection (Dictionary<TKey, TValue> dictionary)
{
if (dictionary == null)
throw new ArgumentNullException ("dictionary");
this.dictionary = dictionary;
}
public void CopyTo (TValue [] array, int index)
{
if (array == null)
throw new ArgumentNullException ("array");
if (index < 0)
throw new ArgumentOutOfRangeException ("index");
// we want no exception for index==array.Length && dictionary.Count == 0
if (index > array.Length)
throw new ArgumentException ("index larger than largest valid index of array");
if (array.Length - index < dictionary.Count)
throw new ArgumentException ("Destination array cannot hold the requested elements!");
for (int i = 0; i < dictionary.table.Length; i++) {
int cur = dictionary.table [i] - 1;
while (cur != NO_SLOT) {
array [index++] = dictionary.valueSlots [cur];
cur = dictionary.linkSlots [cur].Next;
}
}
}
public Enumerator GetEnumerator ()
{
return new Enumerator (dictionary);
}
void ICollection<TValue>.Add (TValue item)
{
throw new NotSupportedException ("this is a read-only collection");
}
void ICollection<TValue>.Clear ()
{
throw new NotSupportedException ("this is a read-only collection");
}
bool ICollection<TValue>.Contains (TValue item)
{
return dictionary.ContainsValue (item);
}
bool ICollection<TValue>.Remove (TValue item)
{
throw new NotSupportedException ("this is a read-only collection");
}
IEnumerator<TValue> IEnumerable<TValue>.GetEnumerator ()
{
return this.GetEnumerator ();
}
void ICollection.CopyTo (Array array, int index)
{
CopyTo ((TValue []) array, index);
}
IEnumerator IEnumerable.GetEnumerator ()
{
return this.GetEnumerator ();
}
public int Count {
get { return dictionary.Count; }
}
bool ICollection<TValue>.IsReadOnly {
get { return true; }
}
bool ICollection.IsSynchronized {
get { return false; }
}
object ICollection.SyncRoot {
get { return ((ICollection) dictionary).SyncRoot; }
}
[Serializable]
public struct Enumerator : IEnumerator<TValue>, IDisposable, IEnumerator {
Dictionary<TKey, TValue>.Enumerator host_enumerator;
internal Enumerator (Dictionary<TKey,TValue> host)
{
host_enumerator = host.GetEnumerator ();
}
public void Dispose ()
{
host_enumerator.Dispose();
}
public bool MoveNext ()
{
return host_enumerator.MoveNext ();
}
public TValue Current {
get { return host_enumerator.CurrentValue; }
}
object IEnumerator.Current {
get { return host_enumerator.CurrentValue; }
}
void IEnumerator.Reset ()
{
((IEnumerator)host_enumerator).Reset ();
}
}
}
}
}
#endif