PKHeX/PKHeX.Core/Util/Util.cs

208 lines
7.3 KiB
C#
Raw Normal View History

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
2016-07-09 22:30:12 +00:00
namespace PKHeX.Core
2016-07-09 22:30:12 +00:00
{
public static partial class Util
2016-07-09 22:30:12 +00:00
{
/// <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(string value)
2016-07-09 22:30:12 +00:00
{
int result = 0;
if (string.IsNullOrEmpty(value))
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;
2016-07-09 22:30:12 +00:00
}
/// <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(string value)
2016-07-09 22:30:12 +00:00
{
uint result = 0;
if (string.IsNullOrEmpty(value))
return result;
foreach (var c in value)
{
if (!IsNum(c))
continue;
result *= 10;
result += (uint)(c - '0');
}
return result;
2016-07-09 22:30:12 +00:00
}
/// <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(string value)
2016-07-09 22:30:12 +00:00
{
uint result = 0;
if (string.IsNullOrEmpty(value))
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;
2016-07-09 22:30:12 +00:00
}
2020-02-13 02:10:03 +00:00
/// <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(string value)
{
ulong result = 0;
if (string.IsNullOrEmpty(value))
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;
}
2016-07-09 22:30:12 +00:00
public static byte[] GetBytesFromHexString(string seed)
{
return Enumerable.Range(0, seed.Length)
.Where(x => x % 2 == 0)
.Select(x => Convert.ToByte(seed.Substring(x, 2), 16))
.Reverse().ToArray();
}
public static string GetHexStringFromBytes(byte[] data, int offset, int length)
{
data = data.Skip(offset).Take(length).Reverse().ToArray();
return BitConverter.ToString(data).Replace("-", string.Empty);
}
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.Substring(1, word.Length - 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 0xFFFF terminator.
/// </summary>
/// <param name="input">String to trim.</param>
/// <returns>Trimmed string.</returns>
public static void TrimFromFFFF(StringBuilder input) => TrimFromFirst(input, (char)0xFFFF);
/// <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');
/// <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 void TrimFromZero(StringBuilder 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.Substring(0, index);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void TrimFromFirst(StringBuilder input, char c)
{
for (int i = 0; i < input.Length; i++)
{
if (input[i] == c)
input.Remove(i, input.Length - i);
}
}
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;
}
2016-07-09 22:30:12 +00:00
}
}