niko
747 lines
20 KiB
C#
747 lines
20 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using Google.Protobuf.Reflection;
|
|
|
|
namespace Google.Protobuf.Collections
|
|
{
|
|
// Token: 0x0200006F RID: 111
|
|
public sealed class MapField<TKey, TValue> : IDeepCloneable<MapField<TKey, TValue>>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IEquatable<MapField<TKey, TValue>>, IDictionary, ICollection
|
|
{
|
|
// Token: 0x0600060B RID: 1547 RVA: 0x000151CC File Offset: 0x000133CC
|
|
public MapField<TKey, TValue> Clone()
|
|
{
|
|
MapField<TKey, TValue> mapField = new MapField<TKey, TValue>();
|
|
if (typeof(IDeepCloneable<TValue>).IsAssignableFrom(typeof(TValue)))
|
|
{
|
|
using (LinkedList<KeyValuePair<TKey, TValue>>.Enumerator enumerator = this.list.GetEnumerator())
|
|
{
|
|
while (enumerator.MoveNext())
|
|
{
|
|
KeyValuePair<TKey, TValue> keyValuePair = enumerator.Current;
|
|
mapField.Add(keyValuePair.Key, ((IDeepCloneable<TValue>)((object)keyValuePair.Value)).Clone());
|
|
}
|
|
return mapField;
|
|
}
|
|
}
|
|
mapField.Add(this);
|
|
return mapField;
|
|
}
|
|
|
|
// Token: 0x0600060C RID: 1548 RVA: 0x00015264 File Offset: 0x00013464
|
|
public void Add(TKey key, TValue value)
|
|
{
|
|
if (this.ContainsKey(key))
|
|
{
|
|
throw new ArgumentException("Key already exists in map", "key");
|
|
}
|
|
this[key] = value;
|
|
}
|
|
|
|
// Token: 0x0600060D RID: 1549 RVA: 0x00015287 File Offset: 0x00013487
|
|
public bool ContainsKey(TKey key)
|
|
{
|
|
ProtoPreconditions.CheckNotNullUnconstrained<TKey>(key, "key");
|
|
return this.map.ContainsKey(key);
|
|
}
|
|
|
|
// Token: 0x0600060E RID: 1550 RVA: 0x000152A4 File Offset: 0x000134A4
|
|
private bool ContainsValue(TValue value)
|
|
{
|
|
EqualityComparer<TValue> comparer = EqualityComparer<TValue>.Default;
|
|
return this.list.Any((KeyValuePair<TKey, TValue> pair) => comparer.Equals(pair.Value, value));
|
|
}
|
|
|
|
// Token: 0x0600060F RID: 1551 RVA: 0x000152E0 File Offset: 0x000134E0
|
|
public bool Remove(TKey key)
|
|
{
|
|
ProtoPreconditions.CheckNotNullUnconstrained<TKey>(key, "key");
|
|
LinkedListNode<KeyValuePair<TKey, TValue>> linkedListNode;
|
|
if (this.map.TryGetValue(key, out linkedListNode))
|
|
{
|
|
this.map.Remove(key);
|
|
linkedListNode.List.Remove(linkedListNode);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Token: 0x06000610 RID: 1552 RVA: 0x00015328 File Offset: 0x00013528
|
|
public bool TryGetValue(TKey key, out TValue value)
|
|
{
|
|
LinkedListNode<KeyValuePair<TKey, TValue>> linkedListNode;
|
|
if (this.map.TryGetValue(key, out linkedListNode))
|
|
{
|
|
value = linkedListNode.Value.Value;
|
|
return true;
|
|
}
|
|
value = default(TValue);
|
|
return false;
|
|
}
|
|
|
|
// Token: 0x170001B5 RID: 437
|
|
public TValue this[TKey key]
|
|
{
|
|
get
|
|
{
|
|
ProtoPreconditions.CheckNotNullUnconstrained<TKey>(key, "key");
|
|
TValue tvalue;
|
|
if (this.TryGetValue(key, out tvalue))
|
|
{
|
|
return tvalue;
|
|
}
|
|
throw new KeyNotFoundException();
|
|
}
|
|
set
|
|
{
|
|
ProtoPreconditions.CheckNotNullUnconstrained<TKey>(key, "key");
|
|
if (value == null)
|
|
{
|
|
ProtoPreconditions.CheckNotNullUnconstrained<TValue>(value, "value");
|
|
}
|
|
KeyValuePair<TKey, TValue> keyValuePair = new KeyValuePair<TKey, TValue>(key, value);
|
|
LinkedListNode<KeyValuePair<TKey, TValue>> linkedListNode;
|
|
if (this.map.TryGetValue(key, out linkedListNode))
|
|
{
|
|
linkedListNode.Value = keyValuePair;
|
|
return;
|
|
}
|
|
linkedListNode = this.list.AddLast(keyValuePair);
|
|
this.map[key] = linkedListNode;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001B6 RID: 438
|
|
// (get) Token: 0x06000613 RID: 1555 RVA: 0x000153F8 File Offset: 0x000135F8
|
|
public ICollection<TKey> Keys
|
|
{
|
|
get
|
|
{
|
|
return new MapField<TKey, TValue>.MapView<TKey>(this, (KeyValuePair<TKey, TValue> pair) => pair.Key, new Func<TKey, bool>(this.ContainsKey));
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001B7 RID: 439
|
|
// (get) Token: 0x06000614 RID: 1556 RVA: 0x0001542C File Offset: 0x0001362C
|
|
public ICollection<TValue> Values
|
|
{
|
|
get
|
|
{
|
|
return new MapField<TKey, TValue>.MapView<TValue>(this, (KeyValuePair<TKey, TValue> pair) => pair.Value, new Func<TValue, bool>(this.ContainsValue));
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000615 RID: 1557 RVA: 0x00015460 File Offset: 0x00013660
|
|
public void Add(IDictionary<TKey, TValue> entries)
|
|
{
|
|
ProtoPreconditions.CheckNotNull<IDictionary<TKey, TValue>>(entries, "entries");
|
|
foreach (KeyValuePair<TKey, TValue> keyValuePair in entries)
|
|
{
|
|
this.Add(keyValuePair.Key, keyValuePair.Value);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000616 RID: 1558 RVA: 0x000154C4 File Offset: 0x000136C4
|
|
public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
|
|
{
|
|
return this.list.GetEnumerator();
|
|
}
|
|
|
|
// Token: 0x06000617 RID: 1559 RVA: 0x000154D6 File Offset: 0x000136D6
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
return this.GetEnumerator();
|
|
}
|
|
|
|
// Token: 0x06000618 RID: 1560 RVA: 0x000154DE File Offset: 0x000136DE
|
|
void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
|
|
{
|
|
this.Add(item.Key, item.Value);
|
|
}
|
|
|
|
// Token: 0x06000619 RID: 1561 RVA: 0x000154F4 File Offset: 0x000136F4
|
|
public void Clear()
|
|
{
|
|
this.list.Clear();
|
|
this.map.Clear();
|
|
}
|
|
|
|
// Token: 0x0600061A RID: 1562 RVA: 0x0001550C File Offset: 0x0001370C
|
|
bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item)
|
|
{
|
|
TValue tvalue;
|
|
return this.TryGetValue(item.Key, out tvalue) && EqualityComparer<TValue>.Default.Equals(item.Value, tvalue);
|
|
}
|
|
|
|
// Token: 0x0600061B RID: 1563 RVA: 0x0001553E File Offset: 0x0001373E
|
|
void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
|
|
{
|
|
this.list.CopyTo(array, arrayIndex);
|
|
}
|
|
|
|
// Token: 0x0600061C RID: 1564 RVA: 0x00015550 File Offset: 0x00013750
|
|
bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
|
|
{
|
|
if (item.Key == null)
|
|
{
|
|
throw new ArgumentException("Key is null", "item");
|
|
}
|
|
LinkedListNode<KeyValuePair<TKey, TValue>> linkedListNode;
|
|
if (this.map.TryGetValue(item.Key, out linkedListNode) && EqualityComparer<TValue>.Default.Equals(item.Value, linkedListNode.Value.Value))
|
|
{
|
|
this.map.Remove(item.Key);
|
|
linkedListNode.List.Remove(linkedListNode);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Token: 0x170001B8 RID: 440
|
|
// (get) Token: 0x0600061D RID: 1565 RVA: 0x000155D4 File Offset: 0x000137D4
|
|
public int Count
|
|
{
|
|
get
|
|
{
|
|
return this.list.Count;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001B9 RID: 441
|
|
// (get) Token: 0x0600061E RID: 1566 RVA: 0x0000761F File Offset: 0x0000581F
|
|
public bool IsReadOnly
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600061F RID: 1567 RVA: 0x000155E1 File Offset: 0x000137E1
|
|
public override bool Equals(object other)
|
|
{
|
|
return this.Equals(other as MapField<TKey, TValue>);
|
|
}
|
|
|
|
// Token: 0x06000620 RID: 1568 RVA: 0x000155F0 File Offset: 0x000137F0
|
|
public override int GetHashCode()
|
|
{
|
|
EqualityComparer<TValue> @default = EqualityComparer<TValue>.Default;
|
|
int num = 0;
|
|
foreach (KeyValuePair<TKey, TValue> keyValuePair in this.list)
|
|
{
|
|
int num2 = num;
|
|
TKey key = keyValuePair.Key;
|
|
num = num2 ^ (key.GetHashCode() * 31 + @default.GetHashCode(keyValuePair.Value));
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x06000621 RID: 1569 RVA: 0x00015670 File Offset: 0x00013870
|
|
public bool Equals(MapField<TKey, TValue> other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (other == this)
|
|
{
|
|
return true;
|
|
}
|
|
if (other.Count != this.Count)
|
|
{
|
|
return false;
|
|
}
|
|
EqualityComparer<TValue> @default = EqualityComparer<TValue>.Default;
|
|
foreach (KeyValuePair<TKey, TValue> keyValuePair in this)
|
|
{
|
|
TValue tvalue;
|
|
if (!other.TryGetValue(keyValuePair.Key, out tvalue))
|
|
{
|
|
return false;
|
|
}
|
|
if (!@default.Equals(tvalue, keyValuePair.Value))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x06000622 RID: 1570 RVA: 0x00015704 File Offset: 0x00013904
|
|
public void AddEntriesFrom(CodedInputStream input, MapField<TKey, TValue>.Codec codec)
|
|
{
|
|
MapField<TKey, TValue>.Codec.MessageAdapter messageAdapter = new MapField<TKey, TValue>.Codec.MessageAdapter(codec);
|
|
do
|
|
{
|
|
messageAdapter.Reset();
|
|
input.ReadMessage(messageAdapter);
|
|
this[messageAdapter.Key] = messageAdapter.Value;
|
|
}
|
|
while (input.MaybeConsumeTag(codec.MapTag));
|
|
}
|
|
|
|
// Token: 0x06000623 RID: 1571 RVA: 0x00015748 File Offset: 0x00013948
|
|
public void WriteTo(CodedOutputStream output, MapField<TKey, TValue>.Codec codec)
|
|
{
|
|
MapField<TKey, TValue>.Codec.MessageAdapter messageAdapter = new MapField<TKey, TValue>.Codec.MessageAdapter(codec);
|
|
foreach (KeyValuePair<TKey, TValue> keyValuePair in this.list)
|
|
{
|
|
messageAdapter.Key = keyValuePair.Key;
|
|
messageAdapter.Value = keyValuePair.Value;
|
|
output.WriteTag(codec.MapTag);
|
|
output.WriteMessage(messageAdapter);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000624 RID: 1572 RVA: 0x000157C8 File Offset: 0x000139C8
|
|
public int CalculateSize(MapField<TKey, TValue>.Codec codec)
|
|
{
|
|
if (this.Count == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
MapField<TKey, TValue>.Codec.MessageAdapter messageAdapter = new MapField<TKey, TValue>.Codec.MessageAdapter(codec);
|
|
int num = 0;
|
|
foreach (KeyValuePair<TKey, TValue> keyValuePair in this.list)
|
|
{
|
|
messageAdapter.Key = keyValuePair.Key;
|
|
messageAdapter.Value = keyValuePair.Value;
|
|
num += CodedOutputStream.ComputeRawVarint32Size(codec.MapTag);
|
|
num += CodedOutputStream.ComputeMessageSize(messageAdapter);
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x06000625 RID: 1573 RVA: 0x0001585C File Offset: 0x00013A5C
|
|
public override string ToString()
|
|
{
|
|
StringWriter stringWriter = new StringWriter();
|
|
JsonFormatter.Default.WriteDictionary(stringWriter, this);
|
|
return stringWriter.ToString();
|
|
}
|
|
|
|
// Token: 0x06000626 RID: 1574 RVA: 0x00015881 File Offset: 0x00013A81
|
|
void IDictionary.Add(object key, object value)
|
|
{
|
|
this.Add((TKey)((object)key), (TValue)((object)value));
|
|
}
|
|
|
|
// Token: 0x06000627 RID: 1575 RVA: 0x00015895 File Offset: 0x00013A95
|
|
bool IDictionary.Contains(object key)
|
|
{
|
|
return key is TKey && this.ContainsKey((TKey)((object)key));
|
|
}
|
|
|
|
// Token: 0x06000628 RID: 1576 RVA: 0x000158AD File Offset: 0x00013AAD
|
|
IDictionaryEnumerator IDictionary.GetEnumerator()
|
|
{
|
|
return new MapField<TKey, TValue>.DictionaryEnumerator(this.GetEnumerator());
|
|
}
|
|
|
|
// Token: 0x06000629 RID: 1577 RVA: 0x000158BA File Offset: 0x00013ABA
|
|
void IDictionary.Remove(object key)
|
|
{
|
|
ProtoPreconditions.CheckNotNull<object>(key, "key");
|
|
if (!(key is TKey))
|
|
{
|
|
return;
|
|
}
|
|
this.Remove((TKey)((object)key));
|
|
}
|
|
|
|
// Token: 0x0600062A RID: 1578 RVA: 0x000158DE File Offset: 0x00013ADE
|
|
void ICollection.CopyTo(Array array, int index)
|
|
{
|
|
((ICollection)this.Select((KeyValuePair<TKey, TValue> pair) => new DictionaryEntry(pair.Key, pair.Value)).ToList<DictionaryEntry>()).CopyTo(array, index);
|
|
}
|
|
|
|
// Token: 0x170001BA RID: 442
|
|
// (get) Token: 0x0600062B RID: 1579 RVA: 0x0000761F File Offset: 0x0000581F
|
|
bool IDictionary.IsFixedSize
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001BB RID: 443
|
|
// (get) Token: 0x0600062C RID: 1580 RVA: 0x00015911 File Offset: 0x00013B11
|
|
ICollection IDictionary.Keys
|
|
{
|
|
get
|
|
{
|
|
return (ICollection)this.Keys;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001BC RID: 444
|
|
// (get) Token: 0x0600062D RID: 1581 RVA: 0x0001591E File Offset: 0x00013B1E
|
|
ICollection IDictionary.Values
|
|
{
|
|
get
|
|
{
|
|
return (ICollection)this.Values;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001BD RID: 445
|
|
// (get) Token: 0x0600062E RID: 1582 RVA: 0x0000761F File Offset: 0x0000581F
|
|
bool ICollection.IsSynchronized
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001BE RID: 446
|
|
// (get) Token: 0x0600062F RID: 1583 RVA: 0x000142A1 File Offset: 0x000124A1
|
|
object ICollection.SyncRoot
|
|
{
|
|
get
|
|
{
|
|
return this;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001BF RID: 447
|
|
object IDictionary.this[object key]
|
|
{
|
|
get
|
|
{
|
|
ProtoPreconditions.CheckNotNull<object>(key, "key");
|
|
if (!(key is TKey))
|
|
{
|
|
return null;
|
|
}
|
|
TValue tvalue;
|
|
this.TryGetValue((TKey)((object)key), out tvalue);
|
|
return tvalue;
|
|
}
|
|
set
|
|
{
|
|
this[(TKey)((object)key)] = (TValue)((object)value);
|
|
}
|
|
}
|
|
|
|
// Token: 0x04000266 RID: 614
|
|
private readonly Dictionary<TKey, LinkedListNode<KeyValuePair<TKey, TValue>>> map = new Dictionary<TKey, LinkedListNode<KeyValuePair<TKey, TValue>>>();
|
|
|
|
// Token: 0x04000267 RID: 615
|
|
private readonly LinkedList<KeyValuePair<TKey, TValue>> list = new LinkedList<KeyValuePair<TKey, TValue>>();
|
|
|
|
// Token: 0x020000C8 RID: 200
|
|
private class DictionaryEnumerator : IDictionaryEnumerator, IEnumerator
|
|
{
|
|
// Token: 0x06000787 RID: 1927 RVA: 0x00017941 File Offset: 0x00015B41
|
|
internal DictionaryEnumerator(IEnumerator<KeyValuePair<TKey, TValue>> enumerator)
|
|
{
|
|
this.enumerator = enumerator;
|
|
}
|
|
|
|
// Token: 0x06000788 RID: 1928 RVA: 0x00017950 File Offset: 0x00015B50
|
|
public bool MoveNext()
|
|
{
|
|
return this.enumerator.MoveNext();
|
|
}
|
|
|
|
// Token: 0x06000789 RID: 1929 RVA: 0x0001795D File Offset: 0x00015B5D
|
|
public void Reset()
|
|
{
|
|
this.enumerator.Reset();
|
|
}
|
|
|
|
// Token: 0x170001D4 RID: 468
|
|
// (get) Token: 0x0600078A RID: 1930 RVA: 0x0001796A File Offset: 0x00015B6A
|
|
public object Current
|
|
{
|
|
get
|
|
{
|
|
return this.Entry;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001D5 RID: 469
|
|
// (get) Token: 0x0600078B RID: 1931 RVA: 0x00017977 File Offset: 0x00015B77
|
|
public DictionaryEntry Entry
|
|
{
|
|
get
|
|
{
|
|
return new DictionaryEntry(this.Key, this.Value);
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001D6 RID: 470
|
|
// (get) Token: 0x0600078C RID: 1932 RVA: 0x0001798C File Offset: 0x00015B8C
|
|
public object Key
|
|
{
|
|
get
|
|
{
|
|
KeyValuePair<TKey, TValue> keyValuePair = this.enumerator.Current;
|
|
return keyValuePair.Key;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001D7 RID: 471
|
|
// (get) Token: 0x0600078D RID: 1933 RVA: 0x000179B4 File Offset: 0x00015BB4
|
|
public object Value
|
|
{
|
|
get
|
|
{
|
|
KeyValuePair<TKey, TValue> keyValuePair = this.enumerator.Current;
|
|
return keyValuePair.Value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x04000305 RID: 773
|
|
private readonly IEnumerator<KeyValuePair<TKey, TValue>> enumerator;
|
|
}
|
|
|
|
// Token: 0x020000C9 RID: 201
|
|
public sealed class Codec
|
|
{
|
|
// Token: 0x0600078E RID: 1934 RVA: 0x000179D9 File Offset: 0x00015BD9
|
|
public Codec(FieldCodec<TKey> keyCodec, FieldCodec<TValue> valueCodec, uint mapTag)
|
|
{
|
|
this.keyCodec = keyCodec;
|
|
this.valueCodec = valueCodec;
|
|
this.mapTag = mapTag;
|
|
}
|
|
|
|
// Token: 0x170001D8 RID: 472
|
|
// (get) Token: 0x0600078F RID: 1935 RVA: 0x000179F6 File Offset: 0x00015BF6
|
|
internal uint MapTag
|
|
{
|
|
get
|
|
{
|
|
return this.mapTag;
|
|
}
|
|
}
|
|
|
|
// Token: 0x04000306 RID: 774
|
|
private readonly FieldCodec<TKey> keyCodec;
|
|
|
|
// Token: 0x04000307 RID: 775
|
|
private readonly FieldCodec<TValue> valueCodec;
|
|
|
|
// Token: 0x04000308 RID: 776
|
|
private readonly uint mapTag;
|
|
|
|
// Token: 0x020000DF RID: 223
|
|
internal class MessageAdapter : IMessage
|
|
{
|
|
// Token: 0x170001FD RID: 509
|
|
// (get) Token: 0x06000818 RID: 2072 RVA: 0x00018B77 File Offset: 0x00016D77
|
|
// (set) Token: 0x06000819 RID: 2073 RVA: 0x00018B7F File Offset: 0x00016D7F
|
|
internal TKey Key { get; set; }
|
|
|
|
// Token: 0x170001FE RID: 510
|
|
// (get) Token: 0x0600081A RID: 2074 RVA: 0x00018B88 File Offset: 0x00016D88
|
|
// (set) Token: 0x0600081B RID: 2075 RVA: 0x00018B90 File Offset: 0x00016D90
|
|
internal TValue Value { get; set; }
|
|
|
|
// Token: 0x0600081C RID: 2076 RVA: 0x00018B99 File Offset: 0x00016D99
|
|
internal MessageAdapter(MapField<TKey, TValue>.Codec codec)
|
|
{
|
|
this.codec = codec;
|
|
}
|
|
|
|
// Token: 0x0600081D RID: 2077 RVA: 0x00018BA8 File Offset: 0x00016DA8
|
|
internal void Reset()
|
|
{
|
|
this.Key = this.codec.keyCodec.DefaultValue;
|
|
this.Value = this.codec.valueCodec.DefaultValue;
|
|
}
|
|
|
|
// Token: 0x0600081E RID: 2078 RVA: 0x00018BD8 File Offset: 0x00016DD8
|
|
public void MergeFrom(CodedInputStream input)
|
|
{
|
|
uint num;
|
|
while ((num = input.ReadTag()) != 0U)
|
|
{
|
|
if (num == this.codec.keyCodec.Tag)
|
|
{
|
|
this.Key = this.codec.keyCodec.Read(input);
|
|
}
|
|
else if (num == this.codec.valueCodec.Tag)
|
|
{
|
|
this.Value = this.codec.valueCodec.Read(input);
|
|
}
|
|
else
|
|
{
|
|
input.SkipLastField();
|
|
}
|
|
}
|
|
if (this.Value == null)
|
|
{
|
|
this.Value = this.codec.valueCodec.Read(new CodedInputStream(MapField<TKey, TValue>.Codec.MessageAdapter.ZeroLengthMessageStreamData));
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600081F RID: 2079 RVA: 0x00018C7C File Offset: 0x00016E7C
|
|
public void WriteTo(CodedOutputStream output)
|
|
{
|
|
this.codec.keyCodec.WriteTagAndValue(output, this.Key);
|
|
this.codec.valueCodec.WriteTagAndValue(output, this.Value);
|
|
}
|
|
|
|
// Token: 0x06000820 RID: 2080 RVA: 0x00018CAC File Offset: 0x00016EAC
|
|
public int CalculateSize()
|
|
{
|
|
return this.codec.keyCodec.CalculateSizeWithTag(this.Key) + this.codec.valueCodec.CalculateSizeWithTag(this.Value);
|
|
}
|
|
|
|
// Token: 0x170001FF RID: 511
|
|
// (get) Token: 0x06000821 RID: 2081 RVA: 0x00018CDB File Offset: 0x00016EDB
|
|
MessageDescriptor IMessage.Descriptor
|
|
{
|
|
get
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0400038E RID: 910
|
|
private static readonly byte[] ZeroLengthMessageStreamData = new byte[1];
|
|
|
|
// Token: 0x0400038F RID: 911
|
|
private readonly MapField<TKey, TValue>.Codec codec;
|
|
}
|
|
}
|
|
|
|
// Token: 0x020000CA RID: 202
|
|
private class MapView<T> : ICollection<T>, IEnumerable<T>, IEnumerable, ICollection
|
|
{
|
|
// Token: 0x06000790 RID: 1936 RVA: 0x000179FE File Offset: 0x00015BFE
|
|
internal MapView(MapField<TKey, TValue> parent, Func<KeyValuePair<TKey, TValue>, T> projection, Func<T, bool> containsCheck)
|
|
{
|
|
this.parent = parent;
|
|
this.projection = projection;
|
|
this.containsCheck = containsCheck;
|
|
}
|
|
|
|
// Token: 0x170001D9 RID: 473
|
|
// (get) Token: 0x06000791 RID: 1937 RVA: 0x00017A1B File Offset: 0x00015C1B
|
|
public int Count
|
|
{
|
|
get
|
|
{
|
|
return this.parent.Count;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001DA RID: 474
|
|
// (get) Token: 0x06000792 RID: 1938 RVA: 0x0000324B File Offset: 0x0000144B
|
|
public bool IsReadOnly
|
|
{
|
|
get
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001DB RID: 475
|
|
// (get) Token: 0x06000793 RID: 1939 RVA: 0x0000761F File Offset: 0x0000581F
|
|
public bool IsSynchronized
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170001DC RID: 476
|
|
// (get) Token: 0x06000794 RID: 1940 RVA: 0x00017A28 File Offset: 0x00015C28
|
|
public object SyncRoot
|
|
{
|
|
get
|
|
{
|
|
return this.parent;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000795 RID: 1941 RVA: 0x00007624 File Offset: 0x00005824
|
|
public void Add(T item)
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
// Token: 0x06000796 RID: 1942 RVA: 0x00007624 File Offset: 0x00005824
|
|
public void Clear()
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
// Token: 0x06000797 RID: 1943 RVA: 0x00017A30 File Offset: 0x00015C30
|
|
public bool Contains(T item)
|
|
{
|
|
return this.containsCheck(item);
|
|
}
|
|
|
|
// Token: 0x06000798 RID: 1944 RVA: 0x00017A40 File Offset: 0x00015C40
|
|
public void CopyTo(T[] array, int arrayIndex)
|
|
{
|
|
if (arrayIndex < 0)
|
|
{
|
|
throw new ArgumentOutOfRangeException("arrayIndex");
|
|
}
|
|
if (arrayIndex + this.Count >= array.Length)
|
|
{
|
|
throw new ArgumentException("Not enough space in the array", "array");
|
|
}
|
|
foreach (T t in this)
|
|
{
|
|
array[arrayIndex++] = t;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000799 RID: 1945 RVA: 0x00017ABC File Offset: 0x00015CBC
|
|
public IEnumerator<T> GetEnumerator()
|
|
{
|
|
return this.parent.list.Select(this.projection).GetEnumerator();
|
|
}
|
|
|
|
// Token: 0x0600079A RID: 1946 RVA: 0x00007624 File Offset: 0x00005824
|
|
public bool Remove(T item)
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
// Token: 0x0600079B RID: 1947 RVA: 0x00017AD9 File Offset: 0x00015CD9
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
return this.GetEnumerator();
|
|
}
|
|
|
|
// Token: 0x0600079C RID: 1948 RVA: 0x00017AE4 File Offset: 0x00015CE4
|
|
public void CopyTo(Array array, int index)
|
|
{
|
|
if (index < 0)
|
|
{
|
|
throw new ArgumentOutOfRangeException("index");
|
|
}
|
|
if (index + this.Count >= array.Length)
|
|
{
|
|
throw new ArgumentException("Not enough space in the array", "array");
|
|
}
|
|
foreach (T t in this)
|
|
{
|
|
array.SetValue(t, index++);
|
|
}
|
|
}
|
|
|
|
// Token: 0x04000309 RID: 777
|
|
private readonly MapField<TKey, TValue> parent;
|
|
|
|
// Token: 0x0400030A RID: 778
|
|
private readonly Func<KeyValuePair<TKey, TValue>, T> projection;
|
|
|
|
// Token: 0x0400030B RID: 779
|
|
private readonly Func<T, bool> containsCheck;
|
|
}
|
|
}
|
|
}
|