mirror of
https://github.com/kwsch/PKHeX
synced 2024-11-27 06:20:25 +00:00
47071b41f3
Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
218 lines
7.7 KiB
C#
218 lines
7.7 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
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);
|
|
private static string TitleCase(string word) => char.ToUpper(word[0]) + word[1..].ToLower();
|
|
|
|
/// <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) => string.IsNullOrWhiteSpace(str) ? string.Empty : string.Concat(str.Where(IsHex));
|
|
|
|
/// <summary>
|
|
/// Returns a new string with each word converted to its appropriate title case.
|
|
/// </summary>
|
|
/// <param name="str">Input string to modify</param>
|
|
public static string ToTitleCase(string str) => string.IsNullOrWhiteSpace(str) ? string.Empty : string.Join(" ", str.Split(' ').Select(TitleCase));
|
|
|
|
/// <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)
|
|
{
|
|
var result = new Dictionary<string, int>[nameArray.Count];
|
|
for (int i = 0; i < result.Length; i++)
|
|
{
|
|
var dict = result[i] = new Dictionary<string, int>();
|
|
var names = nameArray[i];
|
|
for (int j = 0; j < names.Count; j++)
|
|
dict.Add(names[j], j);
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
}
|