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);
}
