PKHeX/PKHeX.Core/Util/Util.cs
Kurt 3c232505e5
Refactoring: Narrow some value types (Species, Move, Form) (#3575)
In this pull request I've changed a ton of method signatures to reflect the more-narrow types of Species, Move# and Form; additionally, I've narrowed other large collections that stored lists of species / permitted values, and reworked them to be more performant with the latest API spaghetti that PKHeX provides. Roamer met locations, usually in a range of [max-min]<64, can be quickly checked using a bitflag operation on a UInt64. Other collections (like "Is this from Colosseum or XD") were eliminated -- shadow state is not transferred COLO<->XD, so having a Shadow ID or matching the met location from a gift/wild encounter is a sufficient check for "originated in XD".
2022-08-26 23:43:36 -07:00

273 lines
8.4 KiB
C#

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Text;
namespace PKHeX.Core;
public static partial class Util
{
/// <inheritdoc cref="ToInt32(ReadOnlySpan{char})"/>
public static int ToInt32(string value) => ToInt32(value.AsSpan());
/// <inheritdoc cref="ToUInt32(ReadOnlySpan{char})"/>
public static uint ToUInt32(string value) => ToUInt32(value.AsSpan());
/// <inheritdoc cref="GetHexValue(ReadOnlySpan{char})"/>
public static uint GetHexValue(string value) => GetHexValue(value.AsSpan());
/// <inheritdoc cref="GetHexValue64(ReadOnlySpan{char})"/>
public static ulong GetHexValue64(string value) => GetHexValue64(value.AsSpan());
/// <inheritdoc cref="GetBytesFromHexString(ReadOnlySpan{char})"/>
public static byte[] GetBytesFromHexString(string value) => GetBytesFromHexString(value.AsSpan());
/// <inheritdoc cref="GetHexStringFromBytes(ReadOnlySpan{byte})"/>
public static string GetHexStringFromBytes(byte[] data, int offset, int length) => GetHexStringFromBytes(data.AsSpan(offset, length));
/// <summary>
/// Parses the string into an <see cref="int"/>, skipping all characters except for valid digits.
/// </summary>
/// <param name="value">String to parse</param>
/// <returns>Parsed value</returns>
public static int ToInt32(ReadOnlySpan<char> value)
{
int result = 0;
if (value.Length == 0)
return result;
bool negative = false;
foreach (var c in value)
{
if (IsNum(c))
{
result *= 10;
result += c;
result -= '0';
}
else if (c == '-' && result == 0)
{
negative = true;
}
}
return negative ? -result : result;
}
/// <summary>
/// Parses the string into a <see cref="uint"/>, skipping all characters except for valid digits.
/// </summary>
/// <param name="value">String to parse</param>
/// <returns>Parsed value</returns>
public static uint ToUInt32(ReadOnlySpan<char> value)
{
uint result = 0;
if (value.Length == 0)
return result;
foreach (var c in value)
{
if (!IsNum(c))
continue;
result *= 10;
result += (uint)(c - '0');
}
return result;
}
/// <summary>
/// Parses the hex string into a <see cref="uint"/>, skipping all characters except for valid digits.
/// </summary>
/// <param name="value">Hex String to parse</param>
/// <returns>Parsed value</returns>
public static uint GetHexValue(ReadOnlySpan<char> value)
{
uint result = 0;
if (value.Length == 0)
return result;
foreach (var c in value)
{
if (IsNum(c))
{
result <<= 4;
result += (uint)(c - '0');
}
else if (IsHexUpper(c))
{
result <<= 4;
result += (uint)(c - 'A' + 10);
}
else if (IsHexLower(c))
{
result <<= 4;
result += (uint)(c - 'a' + 10);
}
}
return result;
}
/// <summary>
/// Parses the hex string into a <see cref="ulong"/>, skipping all characters except for valid digits.
/// </summary>
/// <param name="value">Hex String to parse</param>
/// <returns>Parsed value</returns>
public static ulong GetHexValue64(ReadOnlySpan<char> value)
{
ulong result = 0;
if (value.Length == 0)
return result;
foreach (var c in value)
{
if (IsNum(c))
{
result <<= 4;
result += (uint)(c - '0');
}
else if (IsHexUpper(c))
{
result <<= 4;
result += (uint)(c - 'A' + 10);
}
else if (IsHexLower(c))
{
result <<= 4;
result += (uint)(c - 'a' + 10);
}
}
return result;
}
public static byte[] GetBytesFromHexString(ReadOnlySpan<char> seed)
{
byte[] result = new byte[seed.Length / 2];
for (int i = 0; i < result.Length; i++)
{
var slice = seed.Slice(i * 2, 2);
result[^(i+1)] = (byte)GetHexValue(slice);
}
return result;
}
public static string GetHexStringFromBytes(ReadOnlySpan<byte> arr)
{
var sb = new StringBuilder(arr.Length * 2);
for (int i = arr.Length - 1; i >= 0; i--)
sb.AppendFormat("{0:X2}", arr[i]);
return sb.ToString();
}
private static bool IsNum(char c) => (uint)(c - '0') <= 9;
private static bool IsHexUpper(char c) => (uint)(c - 'A') <= 5;
private static bool IsHexLower(char c) => (uint)(c - 'a') <= 5;
private static bool IsHex(char c) => IsNum(c) || IsHexUpper(c) || IsHexLower(c);
/// <summary>
/// Filters the string down to only valid hex characters, returning a new string.
/// </summary>
/// <param name="str">Input string to filter</param>
public static string GetOnlyHex(string str)
{
if (string.IsNullOrWhiteSpace(str))
return string.Empty;
var sb = new StringBuilder(str.Length);
foreach (var c in str)
{
if (IsHex(c))
sb.Append(c);
}
return sb.ToString();
}
/// <summary>
/// Returns a new string with each word converted to its appropriate title case.
/// </summary>
/// <param name="str">Input string to modify</param>
/// <param name="trim">Trim ends of whitespace</param>
public static string ToTitleCase(ReadOnlySpan<char> str, bool trim = false)
{
int start = 0;
if (trim)
{
// Get First index that isn't a space
while (start < str.Length && char.IsWhiteSpace(str[start]))
start++;
}
if (start == str.Length)
return string.Empty;
int end = str.Length - 1;
if (trim)
{
// Get Last index that isn't a space
while (end > start && char.IsWhiteSpace(str[end]))
end--;
}
var span = str.Slice(start, end - start + 1);
var sb = new StringBuilder(span.Length);
// Add each word to the string builder. Continue from the first index that isn't a space.
// Add the first character as uppercase, then add each successive character as lowercase.
bool first = true;
foreach (char c in span)
{
if (char.IsWhiteSpace(c))
{
first = true;
sb.Append(c);
}
else if (first)
{
sb.Append(char.ToUpper(c));
first = false;
}
else
{
sb.Append(char.ToLower(c));
}
}
return sb.ToString();
}
/// <summary>
/// Trims a string at the first instance of a 0x0000 terminator.
/// </summary>
/// <param name="input">String to trim.</param>
/// <returns>Trimmed string.</returns>
public static string TrimFromZero(string input) => TrimFromFirst(input, '\0');
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static string TrimFromFirst(string input, char c)
{
int index = input.IndexOf(c);
return index < 0 ? input : input[..index];
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void TrimFromFirst(StringBuilder input, char c)
{
for (int i = 0; i < input.Length; i++)
{
if (input[i] != c)
continue;
input.Remove(i, input.Length - i);
return;
}
}
public static Dictionary<string, int>[] GetMultiDictionary(IReadOnlyList<IReadOnlyList<string>> nameArray, int start)
{
var result = new Dictionary<string, int>[nameArray.Count];
for (int i = 0; i < result.Length; i++)
result[i] = GetDictionary(nameArray[i], start);
return result;
}
private static Dictionary<string, int> GetDictionary(IReadOnlyList<string> names, int start)
{
var result = new Dictionary<string, int>(names.Count - start);
for (int i = start; i < names.Count; i++)
result.Add(names[i], i);
return result;
}
}