warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

fix: Removes broken OrderedHashSet and adds a simple OrderedSet (#1756)

Browse source 
> [!CAUTION]
> **BREAKING CHANGE**
> Removed `OrderdHashSet` and `PooledOrderedHashSet` due to bugs.

> [!NOTE]
> **Developer Note**
> The OrderedSet is not a full data structure. It is not particularly efficient. Pull Requests are welcome for a better implementation, especially if it ends up supporting `ISet<T>` and `IReadOnlySet<T>`

## Summary

The ordered hash set was buggy. It's kind of painful to implement, so for now, I added a simple `OrderedSet` to suffice for gumps. Please reach out if this causes disruption!
This commit is contained in:
Kamron Batman 2024-05-03 18:03:26 -07:00 • committed by GitHub
parent dc118d836f
commit 4ea1d79cad
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
30 changed files with 121 additions and 1258 deletions
Download patch file Download diff file Expand all files Collapse all files

46
Projects/Server.Tests/Tests/Collections/OrderedHashSetTests.cs
View file

@ -1,46 +0,0 @@
using System.Linq;
using Server.Collections;
using Xunit;
namespace Server.Tests
{
public class OrderedHashSetTests
{
[Fact]
public void TestOrderedHashSet()
{
var set = new OrderedHashSet<string>(1)
{
"random string1", "another random string1", "another random string2", "another random string3"
};
set.Remove("another random string1");
var list = set.ToList();
string[] arr = { "random string1", "another random string2", "another random string3" };
int i = 0;
foreach (var entry in list)
{
Assert.Equal(entry, arr[i++]);
}
}
[Fact]
public void TestOrderedHashWithNull()
{
var set = new OrderedHashSet<string>(1)
{
"random string1", null, "another random string2", "another random string3"
};
set.Remove("another random string1");
var list = set.ToList();
string[] arr = { "random string1", null, "another random string2", "another random string3" };
int i = 0;
foreach (var entry in list)
{
Assert.Equal(entry, arr[i++]);
}
}
}
}

29
Projects/Server.Tests/Tests/Collections/OrderedSetTests.cs Normal file
View file

@ -0,0 +1,29 @@
using Server.Collections;
using Xunit;
namespace Server.Tests;
public class OrderedSetTests
{
[Fact]
public void TestOrderedSet()
{
int[] expected = [6, 2, 4, 23, 0];
var set = new OrderedSet<int>();
for (var i = 0; i < expected.Length; i++)
{
set.Add(expected[i]);
}
Assert.Equal(expected.Length, set.Count);
Assert.True(set.Contains(4));
Assert.False(set.Contains(8));
int index = 0;
foreach (var value in set)
{
Assert.Equal(expected[index++], value);
}
}
}

578
Projects/Server/Collections/OrderedHashSet.cs
View file

@ -1,578 +0,0 @@
/*************************************************************************
* ModernUO *
* Copyright 2019-2023 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: OrderedHashSet.cs *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*************************************************************************/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using Microsoft.Collections.Extensions;
namespace Server.Collections;
[DebuggerDisplay("Count = {Count}")]
public class OrderedHashSet<TValue> : IList<TValue>
{
private struct Entry
{
public uint HashCode;
public TValue Value;
public int Next; // the index of the next item in the same bucket, -1 if last
}
private static readonly Entry[] InitialEntries = new Entry[1];
private int[] _buckets = HashHelpers.SizeOneIntArray;
private Entry[] _entries = InitialEntries;
private ulong _fastModMultiplier;
private int _count;
private int _version;
#nullable enable
private readonly IEqualityComparer<TValue>? _comparer;
#nullable disable
public int Count => _count;
#nullable enable
public IEqualityComparer<TValue>? Comparer => _comparer;
#nullable disable
public OrderedHashSet()
: this(0)
{
}
public OrderedHashSet(IEqualityComparer<TValue> comparer)
: this(0, comparer)
{
}
public OrderedHashSet(int capacity, IEqualityComparer<TValue> comparer = null)
{
if (capacity < 0)
{
throw new ArgumentOutOfRangeException(nameof(capacity));
}
if (capacity > 0)
{
int newSize = HashHelpers.GetPrime(capacity);
_buckets = new int[newSize];
_entries = new Entry[newSize];
_fastModMultiplier = HashHelpers.GetFastModMultiplier((uint)newSize);
}
if (comparer != EqualityComparer<TValue>.Default)
{
_comparer = comparer;
}
}
public OrderedHashSet(IEnumerable<TValue> collection, IEqualityComparer<TValue> comparer = null)
: this((collection as ICollection<TValue>)?.Count ?? 0, comparer)
{
if (collection == null)
{
throw new ArgumentNullException(nameof(collection));
}
foreach (TValue value in collection)
{
Add(value);
}
}
public bool Contains(TValue item) => TryGetValue(item, out var value) && EqualityComparer<TValue>.Default.Equals(value);
public void Clear()
{
if (_count > 0)
{
Array.Clear(_buckets, 0, _buckets.Length);
Array.Clear(_entries, 0, _count);
_count = 0;
++_version;
}
}
public int EnsureCapacity(int capacity)
{
if (capacity < 0)
{
throw new ArgumentOutOfRangeException(nameof(capacity));
}
if (_entries.Length >= capacity)
{
return _entries.Length;
}
int newSize = HashHelpers.GetPrime(capacity);
Resize(newSize);
++_version;
return newSize;
}
public Enumerator GetEnumerator() => new(this);
void ICollection<TValue>.Add(TValue item) => TryAdd(item);
public bool Add(TValue item) => TryAdd(item);
public int GetOrAdd(TValue value) => TryInsert(null, value);
public int IndexOf(TValue value) => IndexOf(value, out _);
public void Insert(int index, TValue value)
{
if ((uint)index > (uint)Count)
{
throw new ArgumentOutOfRangeException(nameof(index), CollectionThrowStrings.ArgumentOutOfRange_Index);
}
TryInsert(index, value);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private ref int GetBucketRef(uint hashCode)
{
int[] buckets = _buckets!;
return ref buckets[HashHelpers.FastMod(hashCode, (uint)buckets.Length, _fastModMultiplier)];
}
public bool Remove(TValue value)
{
int index = IndexOf(value);
if (index >= 0)
{
RemoveAt(index);
return true;
}
return false;
}
public void RemoveAt(int index)
{
int count = Count;
if ((uint)index >= (uint)count)
{
throw new ArgumentOutOfRangeException(nameof(index), CollectionThrowStrings.ArgumentOutOfRange_Index);
}
// Remove the entry from the bucket
RemoveEntryFromBucket(index);
// Decrement the indices > index
Entry[] entries = _entries;
for (int i = index + 1; i < count; ++i)
{
entries[i - 1] = entries[i];
UpdateBucketIndex(i, incrementAmount: -1);
}
--_count;
entries[_count] = default;
++_version;
}
public void TrimExcess(int capacity)
{
if (capacity < Count)
{
throw new ArgumentOutOfRangeException(nameof(capacity));
}
int newSize = HashHelpers.GetPrime(capacity);
if (newSize < _entries.Length)
{
Resize(newSize);
++_version;
}
}
public bool TryAdd(TValue value) => TryInsert(null, value) != _count - 1;
public bool TryGetValue(TValue value, out TValue actualValue)
{
int index = IndexOf(value);
if (index >= 0)
{
actualValue = _entries[index].Value;
return true;
}
actualValue = default;
return false;
}
public TValue this[int index]
{
get
{
if ((uint)index >= (uint)Count)
{
throw new ArgumentOutOfRangeException(nameof(index), CollectionThrowStrings.ArgumentOutOfRange_Index);
}
return _entries[index].Value;
}
set
{
if ((uint)index >= (uint)Count)
{
throw new ArgumentOutOfRangeException(nameof(index), CollectionThrowStrings.ArgumentOutOfRange_Index);
}
TValue v = value;
int foundIndex = IndexOf(v, out uint hashCode);
if (foundIndex < 0)
{
RemoveEntryFromBucket(index);
Entry entry = new Entry { HashCode = hashCode, Value = value };
AddEntryToBucket(ref entry, index, _buckets);
_entries[index] = entry;
++_version;
}
else if (foundIndex == index)
{
ref Entry entry = ref _entries[index];
entry.Value = value;
}
else
{
throw new ArgumentException(string.Format(CollectionThrowStrings.Argument_AddingDuplicate, v.ToString()));
}
}
}
public bool IsReadOnly => false;
IEnumerator<TValue> IEnumerable<TValue>.GetEnumerator() => GetEnumerator();
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
public void CopyTo(TValue[] array, int arrayIndex)
{
if (array == null)
{
throw new ArgumentNullException(nameof(array));
}
if ((uint)arrayIndex > (uint)array.Length)
{
throw new ArgumentOutOfRangeException(nameof(arrayIndex), CollectionThrowStrings.ArgumentOutOfRange_NeedNonNegNum);
}
int count = Count;
if (array.Length - arrayIndex < count)
{
throw new ArgumentException(CollectionThrowStrings.Arg_ArrayPlusOffTooSmall);
}
Entry[] entries = _entries;
for (int i = 0; i < count; ++i)
{
Entry entry = entries[i];
array[i + arrayIndex] = entry.Value;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private Entry[] Resize(int newSize)
{
int[] newBuckets = new int[newSize];
Entry[] newEntries = new Entry[newSize];
int count = Count;
Array.Copy(_entries, newEntries, count);
_fastModMultiplier = HashHelpers.GetFastModMultiplier((uint)newSize);
for (int i = 0; i < count; ++i)
{
AddEntryToBucket(ref newEntries[i], i, newBuckets);
}
_buckets = newBuckets;
_entries = newEntries;
return newEntries;
}
#nullable enable
private int IndexOf(TValue value, out uint hashCode)
{
ref int bucket = ref Unsafe.NullRef<int>();
int i;
IEqualityComparer<TValue>? comparer = _comparer;
if (comparer == null)
{
hashCode = (uint)(value?.GetHashCode() ?? 0);
bucket = ref GetBucketRef(hashCode);
i = bucket - 1;
if (i >= 0)
{
if (typeof(TValue).IsValueType)
{
// ValueType: Devirtualize with EqualityComparer<TValue>.Default intrinsic
Entry[] entries = _entries;
int collisionCount = 0;
do
{
Entry entry = entries[i];
if (entry.HashCode == hashCode && EqualityComparer<TValue>.Default.Equals(entry.Value, value))
{
break;
}
i = entry.Next;
if (collisionCount >= entries.Length)
{
// The chain of entries forms a loop; which means a concurrent update has happened.
// Break out of the loop and throw, rather than looping forever.
throw new InvalidOperationException(
CollectionThrowStrings.InvalidOperation_ConcurrentOperationsNotSupported
);
}
++collisionCount;
} while (i >= 0);
}
else
{
// Object type: Shared Generic, EqualityComparer<TValue>.Default won't devirtualize (https://github.com/dotnet/runtime/issues/10050),
// so cache in a local rather than get EqualityComparer per loop iteration.
var defaultComparer = EqualityComparer<TValue>.Default;
Entry[] entries = _entries;
int collisionCount = 0;
do
{
Entry entry = entries[i];
if (entry.HashCode == hashCode && defaultComparer.Equals(entry.Value, value))
{
break;
}
i = entry.Next;
if (collisionCount >= entries.Length)
{
// The chain of entries forms a loop; which means a concurrent update has happened.
// Break out of the loop and throw, rather than looping forever.
throw new InvalidOperationException(
CollectionThrowStrings.InvalidOperation_ConcurrentOperationsNotSupported
);
}
++collisionCount;
} while (i >= 0);
}
}
}
else
{
hashCode = (uint)comparer.GetHashCode(value);
bucket = ref GetBucketRef(hashCode);
i = bucket - 1;
if (i >= 0)
{
Entry[] entries = _entries;
int collisionCount = 0;
do
{
Entry entry = entries[i];
if (entry.HashCode == hashCode && comparer.Equals(entry.Value, value))
{
break;
}
i = entry.Next;
if (collisionCount >= entries.Length)
{
// The chain of entries forms a loop; which means a concurrent update has happened.
// Break out of the loop and throw, rather than looping forever.
throw new InvalidOperationException(CollectionThrowStrings.InvalidOperation_ConcurrentOperationsNotSupported);
}
++collisionCount;
} while (i >= 0);
}
}
return i;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private int TryInsert(int? index, TValue value)
{
int i = IndexOf(value, out uint hashCode);
return i >= 0 ? i : AddInternal(index, value, hashCode);
}
private int AddInternal(int? index, TValue value, uint hashCode)
{
Entry[] entries = _entries;
// Check if resize is needed
int count = Count;
if (entries.Length == count || entries.Length == 1)
{
entries = Resize(HashHelpers.ExpandPrime(entries.Length));
}
// Increment indices >= index;
int actualIndex = index ?? count;
for (int i = count - 1; i >= actualIndex; --i)
{
entries[i + 1] = entries[i];
UpdateBucketIndex(i, incrementAmount: 1);
}
ref Entry entry = ref entries[actualIndex];
entry.HashCode = hashCode;
entry.Value = value;
AddEntryToBucket(ref entry, actualIndex, _buckets);
++_count;
++_version;
return actualIndex;
}
#nullable restore
// Returns the index of the next entry in the bucket
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void AddEntryToBucket(ref Entry entry, int entryIndex, int[] buckets)
{
ref int b = ref buckets[(int)(entry.HashCode % (uint)buckets.Length)];
entry.Next = b - 1;
b = entryIndex + 1;
}
private void RemoveEntryFromBucket(int entryIndex)
{
Entry[] entries = _entries;
Entry entry = entries[entryIndex];
ref int bucket = ref GetBucketRef(entry.HashCode);
// Bucket was pointing to removed entry. Update it to point to the next in the chain
if (bucket == entryIndex + 1)
{
bucket = entry.Next + 1;
}
else
{
// Start at the entry the bucket points to, and walk the chain until we find the entry with the index we want to remove, then fix the chain
int i = bucket - 1;
int collisionCount = 0;
while (true)
{
ref Entry e = ref entries[i];
if (e.Next == entryIndex)
{
e.Next = entry.Next;
return;
}
i = e.Next;
if (collisionCount >= entries.Length)
{
// The chain of entries forms a loop; which means a concurrent update has happened.
// Break out of the loop and throw, rather than looping forever.
throw new InvalidOperationException(CollectionThrowStrings.InvalidOperation_ConcurrentOperationsNotSupported);
}
++collisionCount;
}
}
}
private void UpdateBucketIndex(int entryIndex, int incrementAmount)
{
Entry[] entries = _entries;
Entry entry = entries[entryIndex];
ref int bucket = ref GetBucketRef(entry.HashCode);
// Bucket was pointing to entry. Increment the index by incrementAmount.
if (bucket == entryIndex + 1)
{
bucket += incrementAmount;
}
else
{
// Start at the entry the bucket points to, and walk the chain until we find the entry with the index we want to increment.
int i = bucket - 1;
int collisionCount = 0;
while (true)
{
ref Entry e = ref entries[i];
if (e.Next == entryIndex)
{
e.Next += incrementAmount;
return;
}
i = e.Next;
if (collisionCount >= entries.Length)
{
// The chain of entries forms a loop; which means a concurrent update has happened.
// Break out of the loop and throw, rather than looping forever.
throw new InvalidOperationException(CollectionThrowStrings.InvalidOperation_ConcurrentOperationsNotSupported);
}
++collisionCount;
}
}
}
public struct Enumerator : IEnumerator<TValue>
{
private readonly OrderedHashSet<TValue> _orderedHashSet;
private readonly int _version;
private int _index;
private TValue _current;
public TValue Current => _current;
object IEnumerator.Current => _current;
internal Enumerator(OrderedHashSet<TValue> orderedHashSet)
{
_orderedHashSet = orderedHashSet;
_version = orderedHashSet._version;
_index = 0;
_current = default;
}
public void Dispose()
{
}
public bool MoveNext()
{
if (_version != _orderedHashSet._version)
{
throw new InvalidOperationException(CollectionThrowStrings.InvalidOperation_EnumFailedVersion);
}
if (_index < _orderedHashSet.Count)
{
Entry entry = _orderedHashSet._entries[_index];
_current = entry.Value;
++_index;
return true;
}
_current = default;
return false;
}
void IEnumerator.Reset()
{
if (_version != _orderedHashSet._version)
{
throw new InvalidOperationException(CollectionThrowStrings.InvalidOperation_EnumFailedVersion);
}
_index = 0;
_current = default;
}
}
}

62
Projects/Server/Collections/OrderedSet.cs Normal file
View file

@ -0,0 +1,62 @@
/*************************************************************************
* ModernUO *
* Copyright 2019-2024 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: OrderedSet.cs *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*************************************************************************/
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace Server.Collections;
/// <summary>
/// A data structure designed for scenarios where the order of insertion is important.
/// Note: This is not particularly effecient.
/// </summary>
/// <typeparam name="T">The type of elements in the set.</typeparam>
public class OrderedSet<T>
{
private readonly Dictionary<T, int> _dictionary;
private readonly List<T> _list;
public OrderedSet(IEqualityComparer<T> comparer = null)
{
_dictionary = new Dictionary<T, int>(comparer);
_list = [];
}
public int Count => _dictionary.Count;
public int Add(T value)
{
ref var order = ref CollectionsMarshal.GetValueRefOrAddDefault(_dictionary, value, out var exists);
if (exists)
{
return order;
}
_list.Add(value);
return order = _list.Count - 1;
}
public bool Contains(T value) => _dictionary.ContainsKey(value);
public void Clear()
{
_dictionary.Clear();
_list.Clear();
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public List<T>.Enumerator GetEnumerator() => _list.GetEnumerator();
}

602
Projects/Server/Collections/PooledOrderedHashSet.cs
View file

@ -1,602 +0,0 @@
/*************************************************************************
* ModernUO *
* Copyright 2019-2023 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: PooledOrderedHashSet.cs *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*************************************************************************/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using Microsoft.Collections.Extensions;
using Server.Buffers;
namespace Server.Collections;
[DebuggerDisplay("Count = {Count}")]
public class PooledOrderedHashSet<TValue> : IList<TValue>, IDisposable
{
private struct Entry
{
public uint HashCode;
public TValue Value;
public int Next; // the index of the next item in the same bucket, -1 if last
}
private static readonly Entry[] InitialEntries = new Entry[1];
private int[] _buckets = HashHelpers.SizeOneIntArray;
private int _bucketsLength = 1;
private Entry[] _entries = InitialEntries;
private int _entriesLength = 1;
private ulong _fastModMultiplier;
private int _count;
private int _version;
#nullable enable
private readonly IEqualityComparer<TValue>? _comparer;
#nullable disable
public int Count => _count;
#nullable enable
public IEqualityComparer<TValue>? Comparer => _comparer;
#nullable disable
public PooledOrderedHashSet()
: this(0)
{
}
public PooledOrderedHashSet(IEqualityComparer<TValue> comparer)
: this(0, comparer)
{
}
public PooledOrderedHashSet(int capacity, IEqualityComparer<TValue> comparer = null)
{
if (capacity < 0)
{
throw new ArgumentOutOfRangeException(nameof(capacity));
}
if (capacity > 0)
{
int newSize = HashHelpers.GetPrime(capacity);
_buckets = STArrayPool<int>.Shared.Rent(newSize);
_bucketsLength = newSize;
_entries = STArrayPool<Entry>.Shared.Rent(newSize);
_entriesLength = newSize;
_fastModMultiplier = HashHelpers.GetFastModMultiplier((uint)newSize);
}
if (comparer != EqualityComparer<TValue>.Default)
{
_comparer = comparer;
}
}
public PooledOrderedHashSet(IEnumerable<TValue> collection, IEqualityComparer<TValue> comparer = null)
: this((collection as ICollection<TValue>)?.Count ?? 0, comparer)
{
if (collection == null)
{
throw new ArgumentNullException(nameof(collection));
}
foreach (TValue value in collection)
{
Add(value);
}
}
public bool Contains(TValue item) => TryGetValue(item, out var value) && EqualityComparer<TValue>.Default.Equals(value);
public void Clear()
{
if (_count > 0)
{
Array.Clear(_buckets, 0, _bucketsLength);
Array.Clear(_entries, 0, _count);
_count = 0;
++_version;
}
}
public Enumerator GetEnumerator() => new(this);
void ICollection<TValue>.Add(TValue item) => TryAdd(item);
public bool Add(TValue item) => TryAdd(item);
public int GetOrAdd(TValue value) => TryInsert(null, value);
public int IndexOf(TValue value) => IndexOf(value, out _);
public void Insert(int index, TValue value)
{
if ((uint)index > (uint)Count)
{
throw new ArgumentOutOfRangeException(nameof(index), CollectionThrowStrings.ArgumentOutOfRange_Index);
}
TryInsert(index, value);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private ref int GetBucketRef(uint hashCode)
{
int[] buckets = _buckets!;
return ref buckets[HashHelpers.FastMod(hashCode, (uint)_bucketsLength, _fastModMultiplier)];
}
public bool Remove(TValue value)
{
int index = IndexOf(value);
if (index >= 0)
{
RemoveAt(index);
return true;
}
return false;
}
public void RemoveAt(int index)
{
int count = Count;
if ((uint)index >= (uint)count)
{
throw new ArgumentOutOfRangeException(nameof(index), CollectionThrowStrings.ArgumentOutOfRange_Index);
}
// Remove the entry from the bucket
RemoveEntryFromBucket(index);
// Decrement the indices > index
Entry[] entries = _entries;
for (int i = index + 1; i < count; ++i)
{
entries[i - 1] = entries[i];
UpdateBucketIndex(i, incrementAmount: -1);
}
--_count;
entries[_count] = default;
++_version;
}
public bool TryAdd(TValue value) => TryInsert(null, value) != _count - 1;
public bool TryGetValue(TValue value, out TValue actualValue)
{
int index = IndexOf(value);
if (index >= 0)
{
actualValue = _entries[index].Value;
return true;
}
actualValue = default;
return false;
}
public TValue this[int index]
{
get
{
if ((uint)index >= (uint)Count)
{
throw new ArgumentOutOfRangeException(nameof(index), CollectionThrowStrings.ArgumentOutOfRange_Index);
}
return _entries[index].Value;
}
set
{
if ((uint)index >= (uint)Count)
{
throw new ArgumentOutOfRangeException(nameof(index), CollectionThrowStrings.ArgumentOutOfRange_Index);
}
TValue v = value;
int foundIndex = IndexOf(v, out uint hashCode);
if (foundIndex < 0)
{
RemoveEntryFromBucket(index);
Entry entry = new Entry { HashCode = hashCode, Value = value };
AddEntryToBucket(ref entry, index, _buckets, _bucketsLength);
_entries[index] = entry;
++_version;
}
else if (foundIndex == index)
{
ref Entry entry = ref _entries[index];
entry.Value = value;
}
else
{
throw new ArgumentException(string.Format(CollectionThrowStrings.Argument_AddingDuplicate, v.ToString()));
}
}
}
public bool IsReadOnly => false;
IEnumerator<TValue> IEnumerable<TValue>.GetEnumerator() => GetEnumerator();
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
public void CopyTo(TValue[] array, int arrayIndex)
{
if (array == null)
{
throw new ArgumentNullException(nameof(array));
}
if ((uint)arrayIndex > (uint)array.Length)
{
throw new ArgumentOutOfRangeException(nameof(arrayIndex), CollectionThrowStrings.ArgumentOutOfRange_NeedNonNegNum);
}
int count = Count;
if (array.Length - arrayIndex < count)
{
throw new ArgumentException(CollectionThrowStrings.Arg_ArrayPlusOffTooSmall);
}
Entry[] entries = _entries;
for (int i = 0; i < count; ++i)
{
Entry entry = entries[i];
array[i + arrayIndex] = entry.Value;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private Entry[] Resize(int newSize)
{
int[] newBuckets = _buckets.Length < newSize ? STArrayPool<int>.Shared.Rent(newSize) : _buckets;
Entry[] newEntries = _entries.Length < newSize ? STArrayPool<Entry>.Shared.Rent(newSize) : _entries;
int count = Count;
Array.Copy(_entries, newEntries, count);
_fastModMultiplier = HashHelpers.GetFastModMultiplier((uint)newSize);
for (int i = 0; i < count; ++i)
{
AddEntryToBucket(ref newEntries[i], i, newBuckets, newSize);
}
var oldBuckets = _buckets;
var oldEntries = _entries;
if (oldBuckets.Length > 1 && oldBuckets != newBuckets)
{
STArrayPool<int>.Shared.Return(oldBuckets, true);
}
if (oldEntries.Length > 1 && oldEntries != newEntries)
{
STArrayPool<Entry>.Shared.Return(oldEntries, true);
}
_buckets = newBuckets;
_bucketsLength = newSize;
_entries = newEntries;
_entriesLength = newSize;
return newEntries;
}
#nullable enable
private int IndexOf(TValue value, out uint hashCode)
{
ref int bucket = ref Unsafe.NullRef<int>();
int i;
IEqualityComparer<TValue>? comparer = _comparer;
if (comparer == null)
{
hashCode = (uint)value.GetHashCode();
bucket = ref GetBucketRef(hashCode);
i = bucket - 1;
if (i >= 0)
{
if (typeof(TValue).IsValueType)
{
// ValueType: Devirtualize with EqualityComparer<TValue>.Default intrinsic
Entry[] entries = _entries;
int collisionCount = 0;
do
{
Entry entry = entries[i];
if (entry.HashCode == hashCode && EqualityComparer<TValue>.Default.Equals(entry.Value, value))
{
break;
}
i = entry.Next;
if (collisionCount >= _entriesLength)
{
// The chain of entries forms a loop; which means a concurrent update has happened.
// Break out of the loop and throw, rather than looping forever.
throw new InvalidOperationException(
CollectionThrowStrings.InvalidOperation_ConcurrentOperationsNotSupported
);
}
++collisionCount;
} while (i >= 0);
}
else
{
// Object type: Shared Generic, EqualityComparer<TValue>.Default won't devirtualize (https://github.com/dotnet/runtime/issues/10050),
// so cache in a local rather than get EqualityComparer per loop iteration.
var defaultComparer = EqualityComparer<TValue>.Default;
Entry[] entries = _entries;
int collisionCount = 0;
do
{
Entry entry = entries[i];
if (entry.HashCode == hashCode && defaultComparer.Equals(entry.Value, value))
{
break;
}
i = entry.Next;
if (collisionCount >= _entriesLength)
{
// The chain of entries forms a loop; which means a concurrent update has happened.
// Break out of the loop and throw, rather than looping forever.
throw new InvalidOperationException(
CollectionThrowStrings.InvalidOperation_ConcurrentOperationsNotSupported
);
}
++collisionCount;
} while (i >= 0);
}
}
}
else
{
hashCode = (uint)comparer.GetHashCode(value);
bucket = ref GetBucketRef(hashCode);
i = bucket - 1;
if (i >= 0)
{
Entry[] entries = _entries;
int collisionCount = 0;
do
{
Entry entry = entries[i];
if (entry.HashCode == hashCode && comparer.Equals(entry.Value, value))
{
break;
}
i = entry.Next;
if (collisionCount >= _entriesLength)
{
// The chain of entries forms a loop; which means a concurrent update has happened.
// Break out of the loop and throw, rather than looping forever.
throw new InvalidOperationException(CollectionThrowStrings.InvalidOperation_ConcurrentOperationsNotSupported);
}
++collisionCount;
} while (i >= 0);
}
}
return i;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private int TryInsert(int? index, TValue value)
{
int i = IndexOf(value, out uint hashCode);
return i >= 0 ? i : AddInternal(index, value, hashCode);
}
private int AddInternal(int? index, TValue value, uint hashCode)
{
Entry[] entries = _entries;
// Check if resize is needed
int count = Count;
if (_entriesLength == count || entries.Length == 1)
{
entries = Resize(HashHelpers.ExpandPrime(_entriesLength));
}
// Increment indices >= index;
int actualIndex = index ?? count;
for (int i = count - 1; i >= actualIndex; --i)
{
entries[i + 1] = entries[i];
UpdateBucketIndex(i, incrementAmount: 1);
}
ref Entry entry = ref entries[actualIndex];
entry.HashCode = hashCode;
entry.Value = value;
AddEntryToBucket(ref entry, actualIndex, _buckets, _bucketsLength);
++_count;
++_version;
return actualIndex;
}
#nullable restore
// Returns the index of the next entry in the bucket
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void AddEntryToBucket(ref Entry entry, int entryIndex, int[] buckets, int bucketsLength)
{
ref int b = ref buckets[(int)(entry.HashCode % (uint)bucketsLength)];
entry.Next = b - 1;
b = entryIndex + 1;
}
private void RemoveEntryFromBucket(int entryIndex)
{
Entry[] entries = _entries;
Entry entry = entries[entryIndex];
ref int bucket = ref GetBucketRef(entry.HashCode);
// Bucket was pointing to removed entry. Update it to point to the next in the chain
if (bucket == entryIndex + 1)
{
bucket = entry.Next + 1;
}
else
{
// Start at the entry the bucket points to, and walk the chain until we find the entry with the index we want to remove, then fix the chain
int i = bucket - 1;
int collisionCount = 0;
while (true)
{
ref Entry e = ref entries[i];
if (e.Next == entryIndex)
{
e.Next = entry.Next;
return;
}
i = e.Next;
if (collisionCount >= _entriesLength)
{
// The chain of entries forms a loop; which means a concurrent update has happened.
// Break out of the loop and throw, rather than looping forever.
throw new InvalidOperationException(CollectionThrowStrings.InvalidOperation_ConcurrentOperationsNotSupported);
}
++collisionCount;
}
}
}
private void UpdateBucketIndex(int entryIndex, int incrementAmount)
{
Entry[] entries = _entries;
Entry entry = entries[entryIndex];
ref int bucket = ref GetBucketRef(entry.HashCode);
// Bucket was pointing to entry. Increment the index by incrementAmount.
if (bucket == entryIndex + 1)
{
bucket += incrementAmount;
}
else
{
// Start at the entry the bucket points to, and walk the chain until we find the entry with the index we want to increment.
int i = bucket - 1;
int collisionCount = 0;
while (true)
{
ref Entry e = ref entries[i];
if (e.Next == entryIndex)
{
e.Next += incrementAmount;
return;
}
i = e.Next;
if (collisionCount >= _entriesLength)
{
// The chain of entries forms a loop; which means a concurrent update has happened.
// Break out of the loop and throw, rather than looping forever.
throw new InvalidOperationException(CollectionThrowStrings.InvalidOperation_ConcurrentOperationsNotSupported);
}
++collisionCount;
}
}
}
public struct Enumerator : IEnumerator<TValue>
{
private readonly PooledOrderedHashSet<TValue> _PooledOrderedHashSet;
private readonly int _version;
private int _index;
private TValue _current;
public TValue Current => _current;
object IEnumerator.Current => _current;
internal Enumerator(PooledOrderedHashSet<TValue> PooledOrderedHashSet)
{
_PooledOrderedHashSet = PooledOrderedHashSet;
_version = PooledOrderedHashSet._version;
_index = 0;
_current = default;
}
public void Dispose()
{
}
public bool MoveNext()
{
if (_version != _PooledOrderedHashSet._version)
{
throw new InvalidOperationException(CollectionThrowStrings.InvalidOperation_EnumFailedVersion);
}
if (_index < _PooledOrderedHashSet.Count)
{
Entry entry = _PooledOrderedHashSet._entries[_index];
_current = entry.Value;
++_index;
return true;
}
_current = default;
return false;
}
void IEnumerator.Reset()
{
if (_version != _PooledOrderedHashSet._version)
{
throw new InvalidOperationException(CollectionThrowStrings.InvalidOperation_EnumFailedVersion);
}
_index = 0;
_current = default;
}
}
public void Dispose()
{
if (_buckets.Length > 1)
{
STArrayPool<int>.Shared.Return(_buckets, true);
}
if (_entries.Length > 1)
{
STArrayPool<Entry>.Shared.Return(_entries, true);
}
_buckets = HashHelpers.SizeOneIntArray;
_entries = InitialEntries;
_count = 0;
GC.SuppressFinalize(this);
}
~PooledOrderedHashSet()
{
if (_buckets.Length > 1)
{
STArrayPool<int>.Shared.Return(_buckets, true);
}
if (_entries.Length > 1)
{
STArrayPool<Entry>.Shared.Return(_entries, true);
}
_buckets = HashHelpers.SizeOneIntArray;
_entries = InitialEntries;
_count = 0;
}
}

2
Projects/Server/Gumps/Legacy/GumpAlphaRegion.cs
View file

@ -36,7 +36,7 @@ public class GumpAlphaRegion : GumpEntry
public int Height { get; set; } public int Height { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
writer.WriteAscii($"{{ checkertrans {X} {Y} {Width} {Height} }}"); writer.WriteAscii($"{{ checkertrans {X} {Y} {Width} {Height} }}");
} }

2
Projects/Server/Gumps/Legacy/GumpBackground.cs
View file

@ -39,7 +39,7 @@ public class GumpBackground : GumpEntry
public int GumpID { get; set; } public int GumpID { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
writer.WriteAscii($"{{ resizepic {X} {Y} {GumpID} {Width} {Height} }}"); writer.WriteAscii($"{{ resizepic {X} {Y} {GumpID} {Width} {Height} }}");
} }

2
Projects/Server/Gumps/Legacy/GumpButton.cs
View file

@ -54,7 +54,7 @@ public class GumpButton : GumpEntry
public int Param { get; set; } public int Param { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
writer.WriteAscii($"{{ button {X} {Y} {NormalID} {PressedID} {(int)Type} {Param} {ButtonID} }}"); writer.WriteAscii($"{{ button {X} {Y} {NormalID} {PressedID} {(int)Type} {Param} {ButtonID} }}");
} }

2
Projects/Server/Gumps/Legacy/GumpCheck.cs
View file

@ -42,7 +42,7 @@ public class GumpCheck : GumpEntry
public int SwitchID { get; set; } public int SwitchID { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
var initialState = InitialState ? "1" : "0"; var initialState = InitialState ? "1" : "0";
writer.WriteAscii($"{{ checkbox {X} {Y} {InactiveID} {ActiveID} {initialState} {SwitchID} }}"); writer.WriteAscii($"{{ checkbox {X} {Y} {InactiveID} {ActiveID} {initialState} {SwitchID} }}");

2
Projects/Server/Gumps/Legacy/GumpECHandleInput.cs
View file

@ -20,7 +20,7 @@ namespace Server.Gumps;
public class GumpECHandleInput : GumpEntry public class GumpECHandleInput : GumpEntry
{ {
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
writer.Write("{ echandleinput }"u8); writer.Write("{ echandleinput }"u8);
} }

4
Projects/Server/Gumps/Legacy/GumpEntry.cs
View file

@ -23,7 +23,5 @@ public abstract class GumpEntry
} }
} }
// TODO: Replace OrderedHashSet with InsertOnlyHashSet, a copy of HashSet that is ReadOnly compatible, but includes public abstract void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches);
// a public AddIfNotPresent function that returns the index of the element
public abstract void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches);
} }

2
Projects/Server/Gumps/Legacy/GumpGroup.cs
View file

@ -24,7 +24,7 @@ public class GumpGroup : GumpEntry
public int Group { get; set; } public int Group { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
if (Group == 1) if (Group == 1)
{ {

4
Projects/Server/Gumps/Legacy/GumpHtml.cs
View file

@ -45,9 +45,9 @@ public class GumpHtml : GumpEntry
public bool Scrollbar { get; set; } public bool Scrollbar { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
var textIndex = strings.GetOrAdd(Text ?? ""); var textIndex = strings.Add(Text ?? "");
var background = Background ? "1" : "0"; var background = Background ? "1" : "0";
var scrollbar = Scrollbar ? "1" : "0"; var scrollbar = Scrollbar ? "1" : "0";
writer.WriteAscii($"{{ htmlgump {X} {Y} {Width} {Height} {textIndex} {background} {scrollbar} }}"); writer.WriteAscii($"{{ htmlgump {X} {Y} {Width} {Height} {textIndex} {background} {scrollbar} }}");

2
Projects/Server/Gumps/Legacy/GumpHtmlLocalized.cs
View file

@ -101,7 +101,7 @@ public class GumpHtmlLocalized : GumpEntry
public GumpHtmlLocalizedType Type { get; set; } public GumpHtmlLocalizedType Type { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
var background = Background ? "1" : "0"; var background = Background ? "1" : "0";
var scrollbar = Scrollbar ? "1" : "0"; var scrollbar = Scrollbar ? "1" : "0";

2
Projects/Server/Gumps/Legacy/GumpImage.cs
View file

@ -39,7 +39,7 @@ public class GumpImage : GumpEntry
public string Class { get; set; } public string Class { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
var hasHue = Hue != 0; var hasHue = Hue != 0;
var hasClass = !string.IsNullOrEmpty(Class); var hasClass = !string.IsNullOrEmpty(Class);

2
Projects/Server/Gumps/Legacy/GumpImageTileButton.cs
View file

@ -61,7 +61,7 @@ public class GumpImageTileButton : GumpEntry
public int Height { get; set; } public int Height { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
writer.WriteAscii( writer.WriteAscii(
$"{{ buttontileart {X} {Y} {NormalID} {PressedID} {(int)Type} {Param} {ButtonID} {ItemID} {Hue} {Width} {Height} }}" $"{{ buttontileart {X} {Y} {NormalID} {PressedID} {(int)Type} {Param} {ButtonID} {ItemID} {Hue} {Width} {Height} }}"

2
Projects/Server/Gumps/Legacy/GumpImageTiled.cs
View file

@ -39,7 +39,7 @@ public class GumpImageTiled : GumpEntry
public int GumpID { get; set; } public int GumpID { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
writer.WriteAscii($"{{ gumppictiled {X} {Y} {Width} {Height} {GumpID} }}"); writer.WriteAscii($"{{ gumppictiled {X} {Y} {Width} {Height} {GumpID} }}");
} }

2
Projects/Server/Gumps/Legacy/GumpItem.cs
View file

@ -36,7 +36,7 @@ public class GumpItem : GumpEntry
public int Hue { get; set; } public int Hue { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
writer.WriteAscii(Hue == 0 ? $"{{ tilepic {X} {Y} {ItemID} }}" : $"{{ tilepichue {X} {Y} {ItemID} {Hue} }}"); writer.WriteAscii(Hue == 0 ? $"{{ tilepic {X} {Y} {ItemID} }}" : $"{{ tilepichue {X} {Y} {ItemID} {Hue} }}");
} }

2
Projects/Server/Gumps/Legacy/GumpItemProperty.cs
View file

@ -24,7 +24,7 @@ public class GumpItemProperty : GumpEntry
public Serial Serial { get; set; } public Serial Serial { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
writer.WriteAscii($"{{ itemproperty {Serial.Value} }}"); writer.WriteAscii($"{{ itemproperty {Serial.Value} }}");
} }

4
Projects/Server/Gumps/Legacy/GumpLabel.cs
View file

@ -36,9 +36,9 @@ public class GumpLabel : GumpEntry
public string Text { get; set; } public string Text { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
var textIndex = strings.GetOrAdd(Text ?? ""); var textIndex = strings.Add(Text ?? "");
writer.WriteAscii($"{{ text {X} {Y} {Hue} {textIndex} }}"); writer.WriteAscii($"{{ text {X} {Y} {Hue} {textIndex} }}");
} }
} }

4
Projects/Server/Gumps/Legacy/GumpLabelCropped.cs
View file

@ -42,9 +42,9 @@ public class GumpLabelCropped : GumpEntry
public string Text { get; set; } public string Text { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
var textIndex = strings.GetOrAdd(Text ?? ""); var textIndex = strings.Add(Text ?? "");
writer.WriteAscii($"{{ croppedtext {X} {Y} {Width} {Height} {Hue} {textIndex} }}"); writer.WriteAscii($"{{ croppedtext {X} {Y} {Width} {Height} {Hue} {textIndex} }}");
} }
} }

2
Projects/Server/Gumps/Legacy/GumpMasterGump.cs
View file

@ -24,7 +24,7 @@ public class GumpMasterGump : GumpEntry
public int GumpID { get; set; } public int GumpID { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
writer.WriteAscii($"{{ mastergump {GumpID} }}"); writer.WriteAscii($"{{ mastergump {GumpID} }}");
} }

2
Projects/Server/Gumps/Legacy/GumpPage.cs
View file

@ -24,7 +24,7 @@ public class GumpPage : GumpEntry
public int Page { get; set; } public int Page { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
if (Page == 0) if (Page == 0)
{ {

2
Projects/Server/Gumps/Legacy/GumpRadio.cs
View file

@ -42,7 +42,7 @@ public class GumpRadio : GumpEntry
public int SwitchID { get; set; } public int SwitchID { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
var initialState = InitialState ? "1" : "0"; var initialState = InitialState ? "1" : "0";
writer.WriteAscii($"{{ radio {X} {Y} {InactiveID} {ActiveID} {initialState} {SwitchID} }}"); writer.WriteAscii($"{{ radio {X} {Y} {InactiveID} {ActiveID} {initialState} {SwitchID} }}");

2
Projects/Server/Gumps/Legacy/GumpSpriteImage.cs
View file

@ -45,7 +45,7 @@ public class GumpSpriteImage : GumpEntry
public int SY { get; set; } public int SY { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
writer.WriteAscii($"{{ picinpic {X} {Y} {GumpID} {Width} {Height} {SX} {SY} }}"); writer.WriteAscii($"{{ picinpic {X} {Y} {GumpID} {Width} {Height} {SX} {SY} }}");
} }

4
Projects/Server/Gumps/Legacy/GumpTextEntry.cs
View file

@ -45,9 +45,9 @@ public class GumpTextEntry : GumpEntry
public string InitialText { get; set; } public string InitialText { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
var textIndex = strings.GetOrAdd(InitialText ?? ""); var textIndex = strings.Add(InitialText ?? "");
writer.WriteAscii($"{{ textentry {X} {Y} {Width} {Height} {Hue} {EntryID} {textIndex} }}"); writer.WriteAscii($"{{ textentry {X} {Y} {Width} {Height} {Hue} {EntryID} {textIndex} }}");
entries++; entries++;
} }

4
Projects/Server/Gumps/Legacy/GumpTextEntryLimited.cs
View file

@ -50,9 +50,9 @@ public class GumpTextEntryLimited : GumpEntry
public int Size { get; set; } public int Size { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
var textIndex = strings.GetOrAdd(InitialText ?? ""); var textIndex = strings.Add(InitialText ?? "");
writer.WriteAscii($"{{ textentrylimited {X} {Y} {Width} {Height} {Hue} {EntryID} {textIndex} {Size} }}"); writer.WriteAscii($"{{ textentrylimited {X} {Y} {Width} {Height} {Hue} {EntryID} {textIndex} {Size} }}");
entries++; entries++;
} }

2
Projects/Server/Gumps/Legacy/GumpTooltip.cs
View file

@ -32,7 +32,7 @@ public class GumpTooltip : GumpEntry
public string Args { get; set; } public string Args { get; set; }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet<string> strings, ref int entries, ref int switches) public override void AppendTo(ref SpanWriter writer, OrderedSet<string> strings, ref int entries, ref int switches)
{ {
writer.WriteAscii(string.IsNullOrEmpty(Args) ? $"{{ tooltip {Number} }}" : $"{{ tooltip {Number} @{Args}@ }}"); writer.WriteAscii(string.IsNullOrEmpty(Args) ? $"{{ tooltip {Number} }}" : $"{{ tooltip {Number} @{Args}@ }}");
} }

2
Projects/Server/Network/Packets/OutgoingGumpPackets.cs
View file

@ -50,7 +50,7 @@ public static class OutgoingGumpPackets
private static readonly byte[] _layoutBuffer = GC.AllocateUninitializedArray<byte>(0x20000); private static readonly byte[] _layoutBuffer = GC.AllocateUninitializedArray<byte>(0x20000);
private static readonly byte[] _stringsBuffer = GC.AllocateUninitializedArray<byte>(0x20000); private static readonly byte[] _stringsBuffer = GC.AllocateUninitializedArray<byte>(0x20000);
private static readonly byte[] _packBuffer = GC.AllocateUninitializedArray<byte>(0x20000); private static readonly byte[] _packBuffer = GC.AllocateUninitializedArray<byte>(0x20000);
private static readonly OrderedHashSet<string> _stringsList = new(32); private static readonly OrderedSet<string> _stringsList = new();
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void WritePacked(ReadOnlySpan<byte> span, ref SpanWriter writer) public static void WritePacked(ReadOnlySpan<byte> span, ref SpanWriter writer)

2
version.json
View file

@ -1,4 +1,4 @@
{ {
"$schema": "https://raw.githubusercontent.com/dotnet/Nerdbank.GitVersioning/master/src/NerdBank.GitVersioning/version.schema.json", "$schema": "https://raw.githubusercontent.com/dotnet/Nerdbank.GitVersioning/master/src/NerdBank.GitVersioning/version.schema.json",
"version": "0.13.1" "version": "0.13.2"
} }