mirror of
https://github.com/WB3000/nusdownloader.git
synced 2024-11-17 07:09:21 +01:00
273 lines
8.8 KiB
C#
273 lines
8.8 KiB
C#
/* This file is part of libWiiSharp
|
|
* Copyright (C) 2009 Leathl
|
|
*
|
|
* libWiiSharp 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.
|
|
*
|
|
* libWiiSharp is distributed in the hope that it will be
|
|
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* 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.Generic;
|
|
using System.Net;
|
|
|
|
namespace libWiiSharp
|
|
{
|
|
public static class Shared
|
|
{
|
|
/// <summary>
|
|
/// Merges two string arrays into one without double entries.
|
|
/// </summary>
|
|
/// <param name="a"></param>
|
|
/// <param name="b"></param>
|
|
/// <returns></returns>
|
|
public static string[] MergeStringArrays(string[] a, string[] b)
|
|
{
|
|
List<string> sList = new List<string>(a);
|
|
|
|
foreach (string currentString in b)
|
|
if (!sList.Contains(currentString)) sList.Add(currentString);
|
|
|
|
sList.Sort();
|
|
return sList.ToArray();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compares two byte arrays.
|
|
/// </summary>
|
|
/// <param name="first"></param>
|
|
/// <param name="firstIndex"></param>
|
|
/// <param name="second"></param>
|
|
/// <param name="secondIndex"></param>
|
|
/// <param name="length"></param>
|
|
/// <returns></returns>
|
|
public static bool CompareByteArrays(byte[] first, int firstIndex, byte[] second, int secondIndex, int length)
|
|
{
|
|
if (first.Length < length || second.Length < length) return false;
|
|
|
|
for (int i = 0; i < length; i++)
|
|
if (first[firstIndex + i] != second[secondIndex + i]) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compares two byte arrays.
|
|
/// </summary>
|
|
/// <param name="first"></param>
|
|
/// <param name="second"></param>
|
|
/// <returns></returns>
|
|
public static bool CompareByteArrays(byte[] first, byte[] second)
|
|
{
|
|
if (first.Length != second.Length) return false;
|
|
else
|
|
for (int i = 0; i < first.Length; i++)
|
|
if (first[i] != second[i]) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Turns a byte array into a string, default separator is a space.
|
|
/// </summary>
|
|
/// <param name="byteArray"></param>
|
|
/// <param name="separator"></param>
|
|
/// <returns></returns>
|
|
public static string ByteArrayToString(byte[] byteArray, char separator = ' ')
|
|
{
|
|
string res = string.Empty;
|
|
|
|
foreach (byte b in byteArray)
|
|
res += b.ToString("x2").ToUpper() + separator;
|
|
|
|
return res.Remove(res.Length - 1);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Turns a hex string into a byte array.
|
|
/// </summary>
|
|
/// <param name="hexString"></param>
|
|
/// <returns></returns>
|
|
public static byte[] HexStringToByteArray(string hexString)
|
|
{
|
|
byte[] ba = new byte[hexString.Length / 2];
|
|
|
|
for (int i = 0; i < hexString.Length / 2; i++)
|
|
ba[i] = byte.Parse(hexString.Substring(i * 2, 2), System.Globalization.NumberStyles.HexNumber);
|
|
|
|
return ba;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Counts how often the given char exists in the given string.
|
|
/// </summary>
|
|
/// <param name="theString"></param>
|
|
/// <param name="theChar"></param>
|
|
/// <returns></returns>
|
|
public static int CountCharsInString(string theString, char theChar)
|
|
{
|
|
int count = 0;
|
|
|
|
foreach (char thisChar in theString)
|
|
if (thisChar == theChar)
|
|
count++;
|
|
|
|
return count;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pads the given value to a multiple of the given padding value, default padding value is 64.
|
|
/// </summary>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public static long AddPadding(long value)
|
|
{
|
|
return AddPadding(value, 64);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pads the given value to a multiple of the given padding value, default padding value is 64.
|
|
/// </summary>
|
|
/// <param name="value"></param>
|
|
/// <param name="padding"></param>
|
|
/// <returns></returns>
|
|
public static long AddPadding(long value, int padding)
|
|
{
|
|
if (value % padding != 0)
|
|
{
|
|
value = value + (padding - (value % padding));
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pads the given value to a multiple of the given padding value, default padding value is 64.
|
|
/// </summary>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public static int AddPadding(int value)
|
|
{
|
|
return AddPadding(value, 64);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pads the given value to a multiple of the given padding value, default padding value is 64.
|
|
/// </summary>
|
|
/// <param name="value"></param>
|
|
/// <param name="padding"></param>
|
|
/// <returns></returns>
|
|
public static int AddPadding(int value, int padding)
|
|
{
|
|
if (value % padding != 0)
|
|
{
|
|
value = value + (padding - (value % padding));
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Swaps endianness.
|
|
/// </summary>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public static ushort Swap(ushort value)
|
|
{
|
|
return (ushort)IPAddress.HostToNetworkOrder((short)value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Swaps endianness.
|
|
/// </summary>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public static uint Swap(uint value)
|
|
{
|
|
return (uint)IPAddress.HostToNetworkOrder((int)value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Swaps endianness
|
|
/// </summary>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public static ulong Swap(ulong value)
|
|
{
|
|
return (ulong)IPAddress.HostToNetworkOrder((long)value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Turns a ushort array into a byte array.
|
|
/// </summary>
|
|
/// <param name="array"></param>
|
|
/// <returns></returns>
|
|
public static byte[] UShortArrayToByteArray(ushort[] array)
|
|
{
|
|
List<byte> results = new List<byte>();
|
|
foreach (ushort value in array)
|
|
{
|
|
byte[] converted = BitConverter.GetBytes(value);
|
|
results.AddRange(converted);
|
|
}
|
|
return results.ToArray();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Turns a uint array into a byte array.
|
|
/// </summary>
|
|
/// <param name="array"></param>
|
|
/// <returns></returns>
|
|
public static byte[] UIntArrayToByteArray(uint[] array)
|
|
{
|
|
List<byte> results = new List<byte>();
|
|
foreach (uint value in array)
|
|
{
|
|
byte[] converted = BitConverter.GetBytes(value);
|
|
results.AddRange(converted);
|
|
}
|
|
return results.ToArray();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Turns a byte array into a uint array.
|
|
/// </summary>
|
|
/// <param name="array"></param>
|
|
/// <returns></returns>
|
|
public static uint[] ByteArrayToUIntArray(byte[] array)
|
|
{
|
|
UInt32[] converted = new UInt32[array.Length / 4];
|
|
int j = 0;
|
|
|
|
for (int i = 0; i < array.Length; i += 4)
|
|
converted[j++] = BitConverter.ToUInt32(array, i);
|
|
|
|
return converted;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Turns a byte array into a ushort array.
|
|
/// </summary>
|
|
/// <param name="array"></param>
|
|
/// <returns></returns>
|
|
public static ushort[] ByteArrayToUShortArray(byte[] array)
|
|
{
|
|
ushort[] converted = new ushort[array.Length / 2];
|
|
int j = 0;
|
|
|
|
for (int i = 0; i < array.Length; i += 2)
|
|
converted[j++] = BitConverter.ToUInt16(array, i);
|
|
|
|
return converted;
|
|
}
|
|
}
|
|
}
|