rudi
/
NightmareCoreWeb
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Browse Source

Cleaned unused methods and dependencies

master
Gregory Rudolph 2 years ago
parent
5b4c9b6648
commit
b564d7a737
Signed by: rudi
GPG Key ID: EF64F3CBD1A1EBDD
1 changed files with 0 additions and 221 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 221
      Extensions.cs

221
Extensions.cs
Unescape View File

@ -14,54 +14,10 @@ @@ -14,54 +14,10 @@
* 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.Collections.Generic;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Runtime.CompilerServices;
namespace System
{
public static class Extensions
{
public static bool HasAnyFlag<T>(this T value, T flag) where T : struct
{
long lValue = Convert.ToInt64(value);
long lFlag = Convert.ToInt64(flag);
return (lValue & lFlag) != 0;
}
public static string ToHexString(this byte[] byteArray, bool reverse = false)
{
if (reverse)
return byteArray.Reverse().Aggregate("", (current, b) => current + b.ToString("X2"));
else
return byteArray.Aggregate("", (current, b) => current + b.ToString("X2"));
}
public static byte[] ToByteArray(this string str)
{
str = str.Replace(" ", String.Empty);
var res = new byte[str.Length / 2];
for (int i = 0; i < res.Length; ++i)
{
string temp = String.Concat(str[i * 2], str[i * 2 + 1]);
res[i] = Convert.ToByte(temp, 16);
}
return res;
}
public static byte[] ToByteArray(this string value, char separator)
{
return Array.ConvertAll(value.Split(separator), byte.Parse);
}
static uint LeftRotate(this uint value, int shiftCount)
{
return (value << shiftCount) | (value >> (0x20 - shiftCount));
@ -111,182 +67,5 @@ namespace System @@ -111,182 +67,5 @@ namespace System
return combined;
}
public static object[] Combine(this object[] data, params object[][] pData)
{
var combined = data;
foreach (var arr in pData)
{
var currentSize = combined.Length;
Array.Resize(ref combined, currentSize + arr.Length);
Array.Copy(arr, 0, combined, currentSize, arr.Length);
}
return combined;
}
public static void Swap<T>(ref T left, ref T right)
{
T temp = left;
left = right;
right = temp;
}
public static uint[] SerializeObject<T>(this T obj)
{
//if (obj.GetType()<StructLayoutAttribute>() == null)
//return null;
var size = Marshal.SizeOf(typeof(T));
var ptr = Marshal.AllocHGlobal(size);
byte[] array = new byte[size];
Marshal.StructureToPtr(obj, ptr, true);
Marshal.Copy(ptr, array, 0, size);
Marshal.FreeHGlobal(ptr);
uint[] result = new uint[size / 4];
Buffer.BlockCopy(array, 0, result, 0, array.Length);
return result;
}
public static List<T> DeserializeObjects<T>(this ICollection<uint> data)
{
List<T> list = new List<T>();
if (data.Count == 0)
return list;
if (typeof(T).GetCustomAttribute<StructLayoutAttribute>() == null)
return list;
byte[] result = new byte[data.Count * sizeof(uint)];
Buffer.BlockCopy(data.ToArray(), 0, result, 0, result.Length);
var typeSize = Marshal.SizeOf(typeof(T));
var objCount = data.Count / (typeSize / sizeof(uint));
for (var i = 0; i < objCount; ++i)
{
var ptr = Marshal.AllocHGlobal(typeSize);
Marshal.Copy(result, typeSize * i, ptr, typeSize);
list.Add((T)Marshal.PtrToStructure(ptr, typeof(T)));
Marshal.FreeHGlobal(ptr);
}
return list;
}
#region Strings
public static bool IsEmpty(this string str)
{
return string.IsNullOrEmpty(str);
}
public static T ToEnum<T>(this string str) where T : struct
{
T value;
if (!Enum.TryParse(str, out value))
return default;
return value;
}
public static string ConvertFormatSyntax(this string str)
{
string pattern = @"(%\W*\d*[a-zA-Z]*)";
int count = 0;
string result = Regex.Replace(str, pattern, m => string.Concat("{", count++, "}"));
return result;
}
public static bool Like(this string toSearch, string toFind)
{
return toSearch.ToLower().Contains(toFind.ToLower());
}
public static bool IsNumber(this string str)
{
double value;
return double.TryParse(str, out value);
}
public static int GetByteCount(this string str)
{
if (str.IsEmpty())
return 0;
return Encoding.UTF8.GetByteCount(str);
}
public static bool isExtendedLatinCharacter(char wchar)
{
if (isBasicLatinCharacter(wchar))
return true;
if (wchar >= 0x00C0 && wchar <= 0x00D6) // LATIN CAPITAL LETTER A WITH GRAVE - LATIN CAPITAL LETTER O WITH DIAERESIS
return true;
if (wchar >= 0x00D8 && wchar <= 0x00DE) // LATIN CAPITAL LETTER O WITH STROKE - LATIN CAPITAL LETTER THORN
return true;
if (wchar == 0x00DF) // LATIN SMALL LETTER SHARP S
return true;
if (wchar >= 0x00E0 && wchar <= 0x00F6) // LATIN SMALL LETTER A WITH GRAVE - LATIN SMALL LETTER O WITH DIAERESIS
return true;
if (wchar >= 0x00F8 && wchar <= 0x00FE) // LATIN SMALL LETTER O WITH STROKE - LATIN SMALL LETTER THORN
return true;
if (wchar >= 0x0100 && wchar <= 0x012F) // LATIN CAPITAL LETTER A WITH MACRON - LATIN SMALL LETTER I WITH OGONEK
return true;
if (wchar == 0x1E9E) // LATIN CAPITAL LETTER SHARP S
return true;
return false;
}
public static bool isBasicLatinCharacter(char wchar)
{
if (wchar >= 'a' && wchar <= 'z') // LATIN SMALL LETTER A - LATIN SMALL LETTER Z
return true;
if (wchar >= 'A' && wchar <= 'Z') // LATIN CAPITAL LETTER A - LATIN CAPITAL LETTER Z
return true;
return false;
}
#endregion
#region BinaryReader
public static string ReadCString(this BinaryReader reader)
{
byte num;
List<byte> temp = new List<byte>();
while ((num = reader.ReadByte()) != 0)
temp.Add(num);
return Encoding.UTF8.GetString(temp.ToArray());
}
public static string ReadString(this BinaryReader reader, int count)
{
var array = reader.ReadBytes(count);
return Encoding.ASCII.GetString(array);
}
public static string ReadStringFromChars(this BinaryReader reader, int count)
{
return new string(reader.ReadChars(count));
}
public static T Read<T>(this BinaryReader reader) where T : struct
{
byte[] result = reader.ReadBytes(Unsafe.SizeOf<T>());
return Unsafe.ReadUnaligned<T>(ref result[0]);
}
#endregion
}
}
Write Preview
Loading…
Cancel
Save