// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
-#if NET_2_0
-
using System;
using System.Collections;
using System.Globalization;
using System.Runtime.InteropServices;
+using System.Diagnostics;
-namespace System.Collections.Generic {
-
+namespace System.Collections.Generic
+{
/// <summary>
/// Represents a collection of associated keys and values
/// that are sorted by the keys and are accessible by key
/// </summary>
[Serializable]
[ComVisible(false)]
+ [DebuggerDisplay ("Count={Count}")]
+ [DebuggerTypeProxy (typeof (CollectionDebuggerView<,>))]
public class SortedList<TKey, TValue> : IDictionary<TKey, TValue>,
IDictionary,
ICollection,
// ICollection
- public virtual int Count {
+ public int Count {
get {
return inUse;
}
}
}
- public virtual TValue this [TKey key] {
+ public TValue this [TKey key] {
get {
if (key == null)
throw new ArgumentNullException("key");
// Public instance methods.
//
- // IDictionary<TKey, TValue>
-
- public virtual void Add (TKey key, TValue value)
+ public void Add (TKey key, TValue value)
{
if (key == null)
throw new ArgumentNullException ("key");
}
}
- public virtual bool Remove (TKey key)
+ public bool Remove (TKey key)
{
if (key == null)
throw new ArgumentNullException ("key");
// ICollection<KeyValuePair<TKey, TValue>>
- public virtual void Clear ()
+ void ICollection<KeyValuePair<TKey, TValue>>.Clear ()
+ {
+ defaultCapacity = INITIAL_SIZE;
+ this.table = new KeyValuePair<TKey, TValue> [defaultCapacity];
+ inUse = 0;
+ modificationCount++;
+ }
+
+ public void Clear ()
{
defaultCapacity = INITIAL_SIZE;
this.table = new KeyValuePair<TKey, TValue> [defaultCapacity];
void ICollection<KeyValuePair<TKey, TValue>>.CopyTo (KeyValuePair<TKey, TValue>[] array, int arrayIndex)
{
+ if (Count == 0)
+ return;
+
if (null == array)
throw new ArgumentNullException();
void ICollection.CopyTo (Array array, int arrayIndex)
{
+ if (Count == 0)
+ return;
+
if (null == array)
throw new ArgumentNullException();
while (left <= right) {
int guess = (left + right) >> 1;
- int cmp = comparer.Compare (key, table[guess].Key);
+ int cmp = comparer.Compare (table[guess].Key, key);
if (cmp == 0) return guess;
- if (cmp > 0) left = guess+1;
+ if (cmp < 0) left = guess+1;
else right = guess-1;
}
}
}
+ [Serializable]
+ struct KeyEnumerator : IEnumerator <TKey>, IDisposable {
+ const int NOT_STARTED = -2;
+
+ // this MUST be -1, because we depend on it in move next.
+ // we just decr the size, so, 0 - 1 == FINISHED
+ const int FINISHED = -1;
+
+ SortedList <TKey, TValue> l;
+ int idx;
+ int ver;
+
+ internal KeyEnumerator (SortedList<TKey, TValue> l)
+ {
+ this.l = l;
+ idx = NOT_STARTED;
+ ver = l.modificationCount;
+ }
+
+ public void Dispose ()
+ {
+ idx = NOT_STARTED;
+ }
+
+ public bool MoveNext ()
+ {
+ if (ver != l.modificationCount)
+ throw new InvalidOperationException ("Collection was modified after the enumerator was instantiated.");
+
+ if (idx == NOT_STARTED)
+ idx = l.Count;
+
+ return idx != FINISHED && -- idx != FINISHED;
+ }
+
+ public TKey Current {
+ get {
+ if (idx < 0)
+ throw new InvalidOperationException ();
+
+ return l.KeyAt (l.Count - 1 - idx);
+ }
+ }
+
+ void IEnumerator.Reset ()
+ {
+ if (ver != l.modificationCount)
+ throw new InvalidOperationException ("Collection was modified after the enumerator was instantiated.");
+
+ idx = NOT_STARTED;
+ }
+
+ object IEnumerator.Current {
+ get { return Current; }
+ }
+ }
+
+ [Serializable]
+ struct ValueEnumerator : IEnumerator <TValue>, IDisposable {
+ const int NOT_STARTED = -2;
+
+ // this MUST be -1, because we depend on it in move next.
+ // we just decr the size, so, 0 - 1 == FINISHED
+ const int FINISHED = -1;
+
+ SortedList <TKey, TValue> l;
+ int idx;
+ int ver;
+
+ internal ValueEnumerator (SortedList<TKey, TValue> l)
+ {
+ this.l = l;
+ idx = NOT_STARTED;
+ ver = l.modificationCount;
+ }
+
+ public void Dispose ()
+ {
+ idx = NOT_STARTED;
+ }
+
+ public bool MoveNext ()
+ {
+ if (ver != l.modificationCount)
+ throw new InvalidOperationException ("Collection was modified after the enumerator was instantiated.");
+
+ if (idx == NOT_STARTED)
+ idx = l.Count;
+
+ return idx != FINISHED && -- idx != FINISHED;
+ }
+
+ public TValue Current {
+ get {
+ if (idx < 0)
+ throw new InvalidOperationException ();
+
+ return l.ValueAt (l.Count - 1 - idx);
+ }
+ }
+
+ void IEnumerator.Reset ()
+ {
+ if (ver != l.modificationCount)
+ throw new InvalidOperationException ("Collection was modified after the enumerator was instantiated.");
+
+ idx = NOT_STARTED;
+ }
+
+ object IEnumerator.Current {
+ get { return Current; }
+ }
+ }
private class ListKeys : IList<TKey>, ICollection, IEnumerable {
}
public virtual void CopyTo (TKey[] array, int arrayIndex) {
+ if (host.Count == 0)
+ return;
if (array == null)
throw new ArgumentNullException ("array");
if (arrayIndex < 0)
public virtual IEnumerator<TKey> GetEnumerator ()
{
- for (int i = 0; i < host.Count; ++i)
- yield return host.KeyAt (i);
+ /* We couldn't use yield as it does not support Reset () */
+ return new KeyEnumerator (host);
}
//
}
public virtual void CopyTo (TValue[] array, int arrayIndex) {
+ if (host.Count == 0)
+ return;
if (array == null)
throw new ArgumentNullException ("array");
if (arrayIndex < 0)
public virtual IEnumerator<TValue> GetEnumerator ()
{
- for (int i = 0; i < host.Count; ++i)
- yield return host.ValueAt (i);
+ /* We couldn't use yield as it does not support Reset () */
+ return new ValueEnumerator (host);
}
//
} // SortedList
} // System.Collections.Generic
-
-#endif
projects / mono.git / blobdiff