mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
373 lines
11 KiB
C#
373 lines
11 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace System.Runtime.Collections
|
|
{
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Runtime;
|
|
|
|
class NullableKeyDictionary<TKey, TValue> : IDictionary<TKey, TValue>
|
|
{
|
|
bool isNullKeyPresent;
|
|
TValue nullKeyValue;
|
|
IDictionary<TKey, TValue> innerDictionary;
|
|
|
|
public NullableKeyDictionary()
|
|
: base()
|
|
{
|
|
this.innerDictionary = new Dictionary<TKey, TValue>();
|
|
}
|
|
|
|
public int Count
|
|
{
|
|
get { return this.innerDictionary.Count + (this.isNullKeyPresent ? 1 : 0); }
|
|
}
|
|
|
|
public bool IsReadOnly
|
|
{
|
|
get { return false; }
|
|
}
|
|
|
|
public ICollection<TKey> Keys
|
|
{
|
|
get
|
|
{
|
|
return new NullKeyDictionaryKeyCollection<TKey, TValue>(this);
|
|
}
|
|
}
|
|
|
|
public ICollection<TValue> Values
|
|
{
|
|
get { return new NullKeyDictionaryValueCollection<TKey, TValue>(this); }
|
|
}
|
|
|
|
public TValue this[TKey key]
|
|
{
|
|
get
|
|
{
|
|
if (key == null)
|
|
{
|
|
if (this.isNullKeyPresent)
|
|
{
|
|
return this.nullKeyValue;
|
|
}
|
|
else
|
|
{
|
|
throw Fx.Exception.AsError(new KeyNotFoundException());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return this.innerDictionary[key];
|
|
}
|
|
}
|
|
set
|
|
{
|
|
if (key == null)
|
|
{
|
|
this.isNullKeyPresent = true;
|
|
this.nullKeyValue = value;
|
|
}
|
|
else
|
|
{
|
|
this.innerDictionary[key] = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Add(TKey key, TValue value)
|
|
{
|
|
if (key == null)
|
|
{
|
|
if (this.isNullKeyPresent)
|
|
{
|
|
throw Fx.Exception.Argument("key", InternalSR.NullKeyAlreadyPresent);
|
|
}
|
|
this.isNullKeyPresent = true;
|
|
this.nullKeyValue = value;
|
|
}
|
|
else
|
|
{
|
|
this.innerDictionary.Add(key, value);
|
|
}
|
|
}
|
|
|
|
public bool ContainsKey(TKey key)
|
|
{
|
|
return key == null ? this.isNullKeyPresent : this.innerDictionary.ContainsKey(key);
|
|
}
|
|
|
|
public bool Remove(TKey key)
|
|
{
|
|
if (key == null)
|
|
{
|
|
bool result = this.isNullKeyPresent;
|
|
this.isNullKeyPresent = false;
|
|
this.nullKeyValue = default(TValue);
|
|
return result;
|
|
}
|
|
else
|
|
{
|
|
return this.innerDictionary.Remove(key);
|
|
}
|
|
}
|
|
|
|
public bool TryGetValue(TKey key, out TValue value)
|
|
{
|
|
if (key == null)
|
|
{
|
|
if (this.isNullKeyPresent)
|
|
{
|
|
value = this.nullKeyValue;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
value = default(TValue);
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return this.innerDictionary.TryGetValue(key, out value);
|
|
}
|
|
}
|
|
|
|
public void Add(KeyValuePair<TKey, TValue> item)
|
|
{
|
|
Add(item.Key, item.Value);
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
this.isNullKeyPresent = false;
|
|
this.nullKeyValue = default(TValue);
|
|
this.innerDictionary.Clear();
|
|
}
|
|
|
|
public bool Contains(KeyValuePair<TKey, TValue> item)
|
|
{
|
|
if (item.Key == null)
|
|
{
|
|
if (this.isNullKeyPresent)
|
|
{
|
|
return item.Value == null ? this.nullKeyValue == null : item.Value.Equals(this.nullKeyValue);
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return this.innerDictionary.Contains(item);
|
|
}
|
|
}
|
|
|
|
public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
|
|
{
|
|
this.innerDictionary.CopyTo(array, arrayIndex);
|
|
if (this.isNullKeyPresent)
|
|
{
|
|
array[arrayIndex + this.innerDictionary.Count] = new KeyValuePair<TKey, TValue>(default(TKey), this.nullKeyValue);
|
|
}
|
|
}
|
|
|
|
public bool Remove(KeyValuePair<TKey, TValue> item)
|
|
{
|
|
if (item.Key == null)
|
|
{
|
|
if (this.Contains(item))
|
|
{
|
|
this.isNullKeyPresent = false;
|
|
this.nullKeyValue = default(TValue);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return this.innerDictionary.Remove(item);
|
|
}
|
|
}
|
|
|
|
public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
|
|
{
|
|
IEnumerator<KeyValuePair<TKey, TValue>> innerEnumerator = this.innerDictionary.GetEnumerator() as IEnumerator<KeyValuePair<TKey, TValue>>;
|
|
|
|
while (innerEnumerator.MoveNext())
|
|
{
|
|
yield return innerEnumerator.Current;
|
|
}
|
|
|
|
if (this.isNullKeyPresent)
|
|
{
|
|
yield return new KeyValuePair<TKey, TValue>(default(TKey), this.nullKeyValue);
|
|
}
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
return ((IEnumerable<KeyValuePair<TKey, TValue>>)this).GetEnumerator();
|
|
}
|
|
|
|
class NullKeyDictionaryKeyCollection<TypeKey, TypeValue> : ICollection<TypeKey>
|
|
{
|
|
NullableKeyDictionary<TypeKey, TypeValue> nullKeyDictionary;
|
|
|
|
public NullKeyDictionaryKeyCollection(NullableKeyDictionary<TypeKey, TypeValue> nullKeyDictionary)
|
|
{
|
|
this.nullKeyDictionary = nullKeyDictionary;
|
|
}
|
|
|
|
public int Count
|
|
{
|
|
get
|
|
{
|
|
int count = this.nullKeyDictionary.innerDictionary.Keys.Count;
|
|
if (this.nullKeyDictionary.isNullKeyPresent)
|
|
{
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
}
|
|
|
|
public bool IsReadOnly
|
|
{
|
|
get { return true; }
|
|
}
|
|
|
|
public void Add(TypeKey item)
|
|
{
|
|
throw Fx.Exception.AsError(new NotSupportedException(InternalSR.KeyCollectionUpdatesNotAllowed));
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
throw Fx.Exception.AsError(new NotSupportedException(InternalSR.KeyCollectionUpdatesNotAllowed));
|
|
}
|
|
|
|
public bool Contains(TypeKey item)
|
|
{
|
|
return item == null ? this.nullKeyDictionary.isNullKeyPresent : this.nullKeyDictionary.innerDictionary.Keys.Contains(item);
|
|
}
|
|
|
|
public void CopyTo(TypeKey[] array, int arrayIndex)
|
|
{
|
|
this.nullKeyDictionary.innerDictionary.Keys.CopyTo(array, arrayIndex);
|
|
if (this.nullKeyDictionary.isNullKeyPresent)
|
|
{
|
|
array[arrayIndex + this.nullKeyDictionary.innerDictionary.Keys.Count] = default(TypeKey);
|
|
}
|
|
}
|
|
|
|
public bool Remove(TypeKey item)
|
|
{
|
|
throw Fx.Exception.AsError(new NotSupportedException(InternalSR.KeyCollectionUpdatesNotAllowed));
|
|
}
|
|
|
|
public IEnumerator<TypeKey> GetEnumerator()
|
|
{
|
|
foreach (TypeKey item in this.nullKeyDictionary.innerDictionary.Keys)
|
|
{
|
|
yield return item;
|
|
}
|
|
|
|
if (this.nullKeyDictionary.isNullKeyPresent)
|
|
{
|
|
yield return default(TypeKey);
|
|
}
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
return ((IEnumerable<TypeKey>)this).GetEnumerator();
|
|
}
|
|
}
|
|
|
|
class NullKeyDictionaryValueCollection<TypeKey, TypeValue> : ICollection<TypeValue>
|
|
{
|
|
NullableKeyDictionary<TypeKey, TypeValue> nullKeyDictionary;
|
|
|
|
public NullKeyDictionaryValueCollection(NullableKeyDictionary<TypeKey, TypeValue> nullKeyDictionary)
|
|
{
|
|
this.nullKeyDictionary = nullKeyDictionary;
|
|
}
|
|
|
|
public int Count
|
|
{
|
|
get
|
|
{
|
|
int count = this.nullKeyDictionary.innerDictionary.Values.Count;
|
|
if (this.nullKeyDictionary.isNullKeyPresent)
|
|
{
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
}
|
|
|
|
public bool IsReadOnly
|
|
{
|
|
get { return true; }
|
|
}
|
|
|
|
public void Add(TypeValue item)
|
|
{
|
|
throw Fx.Exception.AsError(new NotSupportedException(InternalSR.ValueCollectionUpdatesNotAllowed));
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
throw Fx.Exception.AsError(new NotSupportedException(InternalSR.ValueCollectionUpdatesNotAllowed));
|
|
}
|
|
|
|
public bool Contains(TypeValue item)
|
|
{
|
|
return this.nullKeyDictionary.innerDictionary.Values.Contains(item) ||
|
|
(this.nullKeyDictionary.isNullKeyPresent && this.nullKeyDictionary.nullKeyValue.Equals(item));
|
|
}
|
|
|
|
public void CopyTo(TypeValue[] array, int arrayIndex)
|
|
{
|
|
this.nullKeyDictionary.innerDictionary.Values.CopyTo(array, arrayIndex);
|
|
if (this.nullKeyDictionary.isNullKeyPresent)
|
|
{
|
|
array[arrayIndex + this.nullKeyDictionary.innerDictionary.Values.Count] = this.nullKeyDictionary.nullKeyValue;
|
|
}
|
|
}
|
|
|
|
public bool Remove(TypeValue item)
|
|
{
|
|
throw Fx.Exception.AsError(new NotSupportedException(InternalSR.ValueCollectionUpdatesNotAllowed));
|
|
}
|
|
|
|
public IEnumerator<TypeValue> GetEnumerator()
|
|
{
|
|
foreach (TypeValue item in this.nullKeyDictionary.innerDictionary.Values)
|
|
{
|
|
yield return item;
|
|
}
|
|
|
|
if (this.nullKeyDictionary.isNullKeyPresent)
|
|
{
|
|
yield return this.nullKeyDictionary.nullKeyValue;
|
|
}
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
return ((IEnumerable<TypeValue>)this).GetEnumerator();
|
|
}
|
|
}
|
|
}
|
|
}
|