fix: Cleans up core code (#1187)
**Only one functional change** * Fixes a bug in LogFactory where `Warning` is being logged as `Information` Non-functional changes: * Updates/Fixes copyright headers * Removes namespace scopes for core files. View with [whitespace off](https://github.com/modernuo/ModernUO/pull/1187/files?w=1).
This commit is contained in:
Kamron Batman
GitHub
parent
0138d40bda
commit
f268d5d4e2
262 changed files with 28527 additions and 28646 deletions
|
|
@ -1,6 +1,6 @@
|
|||
/*************************************************************************
|
||||
* ModernUO *
|
||||
* Copyright (C) 2019-2021 - ModernUO Development Team *
|
||||
* Copyright 2019-2022 - ModernUO Development Team *
|
||||
* Email: hi@modernuo.com *
|
||||
* File: ArrayEnumerator.cs *
|
||||
* *
|
||||
|
|
@ -17,63 +17,62 @@ using System;
|
|||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace Server.Collections
|
||||
namespace Server.Collections;
|
||||
|
||||
/// <summary>
|
||||
/// Non-thread safe, non-guarded enumerator for classes that have internal arrays.
|
||||
/// Recommended to copy this and use it as a nested struct.
|
||||
/// Recommend adding version checking to properly guard against modification during enumeration.
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
public struct ArrayEnumerator<T> : IEnumerator<T>
|
||||
{
|
||||
/// <summary>
|
||||
/// Non-thread safe, non-guarded enumerator for classes that have internal arrays.
|
||||
/// Recommended to copy this and use it as a nested struct.
|
||||
/// Recommend adding version checking to properly guard against modification during enumeration.
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
public struct ArrayEnumerator<T> : IEnumerator<T>
|
||||
private readonly T[] _array;
|
||||
private int _index;
|
||||
private T? _current;
|
||||
|
||||
public ArrayEnumerator(T[] array)
|
||||
{
|
||||
private readonly T[] _array;
|
||||
private int _index;
|
||||
private T? _current;
|
||||
_array = array;
|
||||
_index = 0;
|
||||
_current = default;
|
||||
}
|
||||
|
||||
public ArrayEnumerator(T[] array)
|
||||
public void Dispose()
|
||||
{
|
||||
}
|
||||
|
||||
public bool MoveNext()
|
||||
{
|
||||
T[] localList = _array;
|
||||
|
||||
if ((uint)_index < (uint)localList.Length)
|
||||
{
|
||||
_array = array;
|
||||
_index = 0;
|
||||
_current = default;
|
||||
_current = _array[_index++];
|
||||
return true;
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public bool MoveNext()
|
||||
{
|
||||
T[] localList = _array;
|
||||
public T? Current => _current!;
|
||||
|
||||
if ((uint)_index < (uint)localList.Length)
|
||||
object IEnumerator.Current
|
||||
{
|
||||
get
|
||||
{
|
||||
if (_index == 0 || _index == _array.Length + 1)
|
||||
{
|
||||
_current = _array[_index++];
|
||||
return true;
|
||||
throw new InvalidOperationException(nameof(_index));
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
public T? Current => _current!;
|
||||
|
||||
object IEnumerator.Current
|
||||
{
|
||||
get
|
||||
{
|
||||
if (_index == 0 || _index == _array.Length + 1)
|
||||
{
|
||||
throw new InvalidOperationException(nameof(_index));
|
||||
}
|
||||
|
||||
return _current;
|
||||
}
|
||||
}
|
||||
|
||||
void IEnumerator.Reset()
|
||||
{
|
||||
_index = 0;
|
||||
_current = default;
|
||||
return _current;
|
||||
}
|
||||
}
|
||||
|
||||
void IEnumerator.Reset()
|
||||
{
|
||||
_index = 0;
|
||||
_current = default;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*************************************************************************
|
||||
* ModernUO *
|
||||
* Copyright (C) 2019-2021 - ModernUO Development Team *
|
||||
* Copyright 2019-2022 - ModernUO Development Team *
|
||||
* Email: hi@modernuo.com *
|
||||
* File: CollectionHelpers.cs *
|
||||
* *
|
||||
|
|
@ -16,17 +16,16 @@
|
|||
using System.Collections.Generic;
|
||||
using System.Runtime.CompilerServices;
|
||||
|
||||
namespace Server.Collections
|
||||
namespace Server.Collections;
|
||||
|
||||
public static class CollectionHelpers
|
||||
{
|
||||
public static class CollectionHelpers
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
public static void AddNotNull<T>(this ICollection<T> coll, T t) where T : class
|
||||
{
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
public static void AddNotNull<T>(this ICollection<T> coll, T t) where T : class
|
||||
if (t != null)
|
||||
{
|
||||
if (t != null)
|
||||
{
|
||||
coll.Add(t);
|
||||
}
|
||||
coll.Add(t);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*************************************************************************
|
||||
* ModernUO *
|
||||
* Copyright 2019-2021 - ModernUO Development Team *
|
||||
* Copyright 2019-2022 - ModernUO Development Team *
|
||||
* Email: hi@modernuo.com *
|
||||
* File: CollectionThrowStrings.cs *
|
||||
* *
|
||||
|
|
|
|||
|
|
@ -6,120 +6,119 @@ using System;
|
|||
using System.Diagnostics;
|
||||
using System.Runtime.CompilerServices;
|
||||
|
||||
namespace Microsoft.Collections.Extensions
|
||||
namespace Microsoft.Collections.Extensions;
|
||||
|
||||
internal static class HashHelpers
|
||||
{
|
||||
internal static class HashHelpers
|
||||
|
||||
// must never be written to
|
||||
internal static readonly int[] SizeOneIntArray = new int[1];
|
||||
|
||||
// This is the maximum prime smaller than Array.MaxArrayLength
|
||||
public const int MaxPrimeArrayLength = 0x7FEFFFFD;
|
||||
|
||||
public const int HashPrime = 101;
|
||||
|
||||
// Table of prime numbers to use as hash table sizes.
|
||||
// A typical resize algorithm would pick the smallest prime number in this array
|
||||
// that is larger than twice the previous capacity.
|
||||
// Suppose our Hashtable currently has capacity x and enough elements are added
|
||||
// such that a resize needs to occur. Resizing first computes 2x then finds the
|
||||
// first prime in the table greater than 2x, i.e. if primes are ordered
|
||||
// p_1, p_2, ..., p_i, ..., it finds p_n such that p_n-1 < 2x < p_n.
|
||||
// Doubling is important for preserving the asymptotic complexity of the
|
||||
// hashtable operations such as add. Having a prime guarantees that double
|
||||
// hashing does not lead to infinite loops. IE, your hash function will be
|
||||
// h1(key) + i*h2(key), 0 <= i < size. h2 and the size must be relatively prime.
|
||||
// We prefer the low computation costs of higher prime numbers over the increased
|
||||
// memory allocation of a fixed prime number i.e. when right sizing a HashSet.
|
||||
public static readonly int[] primes = {
|
||||
3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, 631, 761, 919,
|
||||
1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591,
|
||||
17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363, 156437,
|
||||
187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403, 968897, 1162687, 1395263,
|
||||
1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559, 5999471, 7199369 };
|
||||
|
||||
public static bool IsPrime(int candidate)
|
||||
{
|
||||
|
||||
// must never be written to
|
||||
internal static readonly int[] SizeOneIntArray = new int[1];
|
||||
|
||||
// This is the maximum prime smaller than Array.MaxArrayLength
|
||||
public const int MaxPrimeArrayLength = 0x7FEFFFFD;
|
||||
|
||||
public const int HashPrime = 101;
|
||||
|
||||
// Table of prime numbers to use as hash table sizes.
|
||||
// A typical resize algorithm would pick the smallest prime number in this array
|
||||
// that is larger than twice the previous capacity.
|
||||
// Suppose our Hashtable currently has capacity x and enough elements are added
|
||||
// such that a resize needs to occur. Resizing first computes 2x then finds the
|
||||
// first prime in the table greater than 2x, i.e. if primes are ordered
|
||||
// p_1, p_2, ..., p_i, ..., it finds p_n such that p_n-1 < 2x < p_n.
|
||||
// Doubling is important for preserving the asymptotic complexity of the
|
||||
// hashtable operations such as add. Having a prime guarantees that double
|
||||
// hashing does not lead to infinite loops. IE, your hash function will be
|
||||
// h1(key) + i*h2(key), 0 <= i < size. h2 and the size must be relatively prime.
|
||||
// We prefer the low computation costs of higher prime numbers over the increased
|
||||
// memory allocation of a fixed prime number i.e. when right sizing a HashSet.
|
||||
public static readonly int[] primes = {
|
||||
3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, 631, 761, 919,
|
||||
1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591,
|
||||
17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363, 156437,
|
||||
187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403, 968897, 1162687, 1395263,
|
||||
1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559, 5999471, 7199369 };
|
||||
|
||||
public static bool IsPrime(int candidate)
|
||||
if ((candidate & 1) != 0)
|
||||
{
|
||||
if ((candidate & 1) != 0)
|
||||
int limit = (int)Math.Sqrt(candidate);
|
||||
for (int divisor = 3; divisor <= limit; divisor += 2)
|
||||
{
|
||||
int limit = (int)Math.Sqrt(candidate);
|
||||
for (int divisor = 3; divisor <= limit; divisor += 2)
|
||||
if (candidate % divisor == 0)
|
||||
{
|
||||
if (candidate % divisor == 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return candidate == 2;
|
||||
}
|
||||
|
||||
public static int GetPrime(int min)
|
||||
{
|
||||
if (min < 0)
|
||||
{
|
||||
throw new ArgumentException("Hashtable's capacity overflowed and went negative. Check load factor, capacity and the current size of the table.");
|
||||
}
|
||||
|
||||
for (int i = 0; i < primes.Length; i++)
|
||||
{
|
||||
int prime = primes[i];
|
||||
if (prime >= min)
|
||||
{
|
||||
return prime;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
//outside of our predefined table.
|
||||
//compute the hard way.
|
||||
for (int i = min | 1; i < int.MaxValue; i += 2)
|
||||
{
|
||||
if (IsPrime(i) && (i - 1) % HashPrime != 0)
|
||||
{
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return min;
|
||||
return true;
|
||||
}
|
||||
return candidate == 2;
|
||||
}
|
||||
|
||||
// Returns size of hashtable to grow to.
|
||||
public static int ExpandPrime(int oldSize)
|
||||
public static int GetPrime(int min)
|
||||
{
|
||||
if (min < 0)
|
||||
{
|
||||
int newSize = 2 * oldSize;
|
||||
|
||||
// Allow the hashtables to grow to maximum possible size (~2G elements) before encountering capacity overflow.
|
||||
// Note that this check works even when _items.Length overflowed thanks to the (uint) cast
|
||||
if ((uint)newSize > MaxPrimeArrayLength && MaxPrimeArrayLength > oldSize)
|
||||
{
|
||||
Debug.Assert(MaxPrimeArrayLength == GetPrime(MaxPrimeArrayLength), "Invalid MaxPrimeArrayLength");
|
||||
return MaxPrimeArrayLength;
|
||||
}
|
||||
|
||||
return GetPrime(newSize);
|
||||
throw new ArgumentException("Hashtable's capacity overflowed and went negative. Check load factor, capacity and the current size of the table.");
|
||||
}
|
||||
|
||||
/// <summary>Returns approximate reciprocal of the divisor: ceil(2**64 / divisor).</summary>
|
||||
/// <remarks>This should only be used on 64-bit.</remarks>
|
||||
public static ulong GetFastModMultiplier(uint divisor) =>
|
||||
ulong.MaxValue / divisor + 1;
|
||||
|
||||
/// <summary>Performs a mod operation using the multiplier pre-computed with <see cref="GetFastModMultiplier"/>.</summary>
|
||||
/// <remarks>This should only be used on 64-bit.</remarks>
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
public static uint FastMod(uint value, uint divisor, ulong multiplier)
|
||||
for (int i = 0; i < primes.Length; i++)
|
||||
{
|
||||
// We use modified Daniel Lemire's fastmod algorithm (https://github.com/dotnet/runtime/pull/406),
|
||||
// which allows to avoid the long multiplication if the divisor is less than 2**31.
|
||||
Debug.Assert(divisor <= int.MaxValue);
|
||||
|
||||
// This is equivalent of (uint)Math.BigMul(multiplier * value, divisor, out _). This version
|
||||
// is faster than BigMul currently because we only need the high bits.
|
||||
uint highbits = (uint)(((((multiplier * value) >> 32) + 1) * divisor) >> 32);
|
||||
|
||||
Debug.Assert(highbits == value % divisor);
|
||||
return highbits;
|
||||
int prime = primes[i];
|
||||
if (prime >= min)
|
||||
{
|
||||
return prime;
|
||||
}
|
||||
}
|
||||
|
||||
//outside of our predefined table.
|
||||
//compute the hard way.
|
||||
for (int i = min | 1; i < int.MaxValue; i += 2)
|
||||
{
|
||||
if (IsPrime(i) && (i - 1) % HashPrime != 0)
|
||||
{
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return min;
|
||||
}
|
||||
|
||||
// Returns size of hashtable to grow to.
|
||||
public static int ExpandPrime(int oldSize)
|
||||
{
|
||||
int newSize = 2 * oldSize;
|
||||
|
||||
// Allow the hashtables to grow to maximum possible size (~2G elements) before encountering capacity overflow.
|
||||
// Note that this check works even when _items.Length overflowed thanks to the (uint) cast
|
||||
if ((uint)newSize > MaxPrimeArrayLength && MaxPrimeArrayLength > oldSize)
|
||||
{
|
||||
Debug.Assert(MaxPrimeArrayLength == GetPrime(MaxPrimeArrayLength), "Invalid MaxPrimeArrayLength");
|
||||
return MaxPrimeArrayLength;
|
||||
}
|
||||
|
||||
return GetPrime(newSize);
|
||||
}
|
||||
|
||||
/// <summary>Returns approximate reciprocal of the divisor: ceil(2**64 / divisor).</summary>
|
||||
/// <remarks>This should only be used on 64-bit.</remarks>
|
||||
public static ulong GetFastModMultiplier(uint divisor) =>
|
||||
ulong.MaxValue / divisor + 1;
|
||||
|
||||
/// <summary>Performs a mod operation using the multiplier pre-computed with <see cref="GetFastModMultiplier"/>.</summary>
|
||||
/// <remarks>This should only be used on 64-bit.</remarks>
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
public static uint FastMod(uint value, uint divisor, ulong multiplier)
|
||||
{
|
||||
// We use modified Daniel Lemire's fastmod algorithm (https://github.com/dotnet/runtime/pull/406),
|
||||
// which allows to avoid the long multiplication if the divisor is less than 2**31.
|
||||
Debug.Assert(divisor <= int.MaxValue);
|
||||
|
||||
// This is equivalent of (uint)Math.BigMul(multiplier * value, divisor, out _). This version
|
||||
// is faster than BigMul currently because we only need the high bits.
|
||||
uint highbits = (uint)(((((multiplier * value) >> 32) + 1) * divisor) >> 32);
|
||||
|
||||
Debug.Assert(highbits == value % divisor);
|
||||
return highbits;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -1,6 +1,6 @@
|
|||
/*************************************************************************
|
||||
* ModernUO *
|
||||
* Copyright 2019-2021 - ModernUO Development Team *
|
||||
* Copyright 2019-2022 - ModernUO Development Team *
|
||||
* Email: hi@modernuo.com *
|
||||
* File: PooledOrderedHashSet.cs *
|
||||
* *
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue