public void Clear() { m_key = TKey.NONE; m_char = '\0'; }
public static Bucket FromKvp(TKey k, TValue v, IEqualityComparer <TKey> eq, Lineage lin) { return(new Bucket(k, v, Empty, eq, lin)); }
public void Add(TKey key, params TValue[] values) => Add(key, (IEnumerable <TValue>)values);
public KeyValue(TKey key, TValue value) { this.Key = key; this.Value = value; }
internal NodeInfo(TKey key, TValue value, DateTime timeouttime) { this.Key = key; this.Value = value; this.timeOutTime = timeouttime; }
/// <summary> /// Create a dummy KeyAndValues with just the key, for lookups. /// </summary> /// <param name="key">The key to use.</param> public KeyAndValues(TKey key) { this.Key = key; this.Count = 0; this.Values = null; }
public Task <Stream?> ReadStreamAsync(TKey key, Checksum?checksum, CancellationToken cancellationToken) => Storage.PerformReadAsync(
bool ICollection <TKey> .Remove(TKey item) => Throw.NotSupportedException <bool>();
public void Add(TKey key, TValue value) { throw new NotSupportedException(); }
void ICollection <TKey> .Add(TKey item) => Throw.NotSupportedException();
bool ICollection <TKey> .Contains(TKey item) => Throw.NotSupportedException <bool>();
public Node(int order, TKey key, Node node) { _count = 1; _children = new KeyValuePair <TKey, Node> [order]; _children[0] = new KeyValuePair <TKey, Node>(key, node); }
public Pair(TKey key, TValue value, bool isDeleted = false) { Key = key; Value = value; IsDeleted = isDeleted; }
public LruCacheItem(TKey key, TValue value) { Key = key; Value = value; }
public TKey(TKey copy) { this.nk = new TKeyNK(copy.nk.value, copy.nk.tt, copy.nk.next); }
public bool ContainsKey(TKey key) { return(false); }
public Node(Node copy) { this.values = copy.values; this.index = copy.index; this.i_val = new LuaTypeValue(copy.i_val); this.i_key = new TKey(copy.i_key); }
public bool Remove(TKey key) { throw new NotSupportedException(); }
public Entry(TKey key, TValue value) { Key = key; evalue = value; }
public bool TryGetValue(TKey key, [MaybeNullWhen(returnValue: false)] out TValue value) { value = default !;
public DictNode(TKey key, TValue val) { Key = key; Value = val; }
public Subscription(TKey key, int subscriptionKey, HandlerHolder holder) { this.key = key; this.subscriptionKey = subscriptionKey; this.holder = holder; }
/// <summary> /// Constructor. Initializes this collection. /// </summary> /// <param name="myDictionary">Dictionary we're using.</param> /// <param name="key">The key we're looking at.</param> public ValuesForKeyCollection(ReadOnlyMultiDictionaryBase <TKey, TValue> myDictionary, TKey key) { this.myDictionary = myDictionary; this.key = key; }
public void Populate(long start, ref TKey key, ref TLeft payload) { this.Start = start; this.Key = key; this.Payload = payload; }
/// <summary>Adds an item to the heap.</summary> public void Insert(TKey key, TValue value) { // Create the entry based on the provided key and value Insert(new KeyValuePair <TKey, TValue>(key, value)); }
public Node(TKey key, TValue value, Node newNode) { Key = key; Value = value; Next = newNode; }
private Bucket NewBucket(TKey k, TValue v, Bucket next, Lineage lin) { return(new Bucket(k, v, next, Eq, lin)); }
public QueueItem(TKey item, double priority) { this.Item = item; this.Priority = priority; }
public KeyHolder(TKey key) { Key = key; }
public TKey(TKey copy) { this.nk = new TKey_nk(copy.nk.value, copy.nk.tt, copy.nk.next); }
public KeyboardEvent(EventState state, TKey key, LockKey lockKey) { m_state = state; m_key = key; m_lockKey = lockKey; }
/// <summary> /// Construct a proxy item /// </summary> public DebuggerProxyItem(TKey InKey, IEnumerable <TValue> InValues) { Key = InKey; Values = InValues.ToArray(); }
public Node() { this.i_val = new LuaTypeValue(); this.i_key = new TKey(); }
internal Node(TKey key, TValue value, int hashcode) : this(key, value, hashcode, null) { }
public Node(TValue i_val, TKey i_key) { this.values = new Node[] { this }; this.index = 0; this.i_val = i_val; this.i_key = i_key; }
/// <summary> /// Add an element with the specified key and value into the container. /// </summary> /// <param name="key">The key of the element to add.</param> /// <param name="item">The value of the element to add.</param> public void Add(TKey key, TValue item) { Assert.IsTrue(m_ThreadIndex >= 0); UnsafeHashMapBase <TKey, TValue> .AddAtomicMulti(m_Buffer, key, item, m_ThreadIndex); }