mirror of
https://github.com/ryujinx-mirror/ryujinx.git
synced 2024-12-05 16:27:25 +00:00
57ea3f93a3
* PPTC meets ExeFS Patching. * InternalVersion = 1865 * Ready! * Optimized the PtcProfiler Load/Save methods.
179 lines
No EOL
5.3 KiB
C#
179 lines
No EOL
5.3 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace ARMeilleure.Translation.PTC
|
|
{
|
|
static class PtcFormatter
|
|
{
|
|
#region "Deserialize"
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static Dictionary<TKey, TValue> DeserializeDictionary<TKey, TValue>(Stream stream, Func<Stream, TValue> valueFunc) where TKey : struct
|
|
{
|
|
Dictionary<TKey, TValue> dictionary = new();
|
|
|
|
int count = DeserializeStructure<int>(stream);
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
TKey key = DeserializeStructure<TKey>(stream);
|
|
TValue value = valueFunc(stream);
|
|
|
|
dictionary.Add(key, value);
|
|
}
|
|
|
|
return dictionary;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static List<T> DeserializeList<T>(Stream stream) where T : struct
|
|
{
|
|
List<T> list = new();
|
|
|
|
int count = DeserializeStructure<int>(stream);
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
T item = DeserializeStructure<T>(stream);
|
|
|
|
list.Add(item);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static T DeserializeStructure<T>(Stream stream) where T : struct
|
|
{
|
|
T structure = default(T);
|
|
|
|
Span<T> spanT = MemoryMarshal.CreateSpan(ref structure, 1);
|
|
int bytesCount = stream.Read(MemoryMarshal.AsBytes(spanT));
|
|
|
|
if (bytesCount != Unsafe.SizeOf<T>())
|
|
{
|
|
throw new EndOfStreamException();
|
|
}
|
|
|
|
return structure;
|
|
}
|
|
#endregion
|
|
|
|
#region "GetSerializeSize"
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static int GetSerializeSizeDictionary<TKey, TValue>(Dictionary<TKey, TValue> dictionary, Func<TValue, int> valueFunc) where TKey : struct
|
|
{
|
|
int size = 0;
|
|
|
|
size += Unsafe.SizeOf<int>();
|
|
|
|
foreach ((_, TValue value) in dictionary)
|
|
{
|
|
size += Unsafe.SizeOf<TKey>();
|
|
size += valueFunc(value);
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static int GetSerializeSizeList<T>(List<T> list) where T : struct
|
|
{
|
|
int size = 0;
|
|
|
|
size += Unsafe.SizeOf<int>();
|
|
|
|
size += list.Count * Unsafe.SizeOf<T>();
|
|
|
|
return size;
|
|
}
|
|
#endregion
|
|
|
|
#region "Serialize"
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void SerializeDictionary<TKey, TValue>(Stream stream, Dictionary<TKey, TValue> dictionary, Action<Stream, TValue> valueAction) where TKey : struct
|
|
{
|
|
SerializeStructure<int>(stream, dictionary.Count);
|
|
|
|
foreach ((TKey key, TValue value) in dictionary)
|
|
{
|
|
SerializeStructure<TKey>(stream, key);
|
|
valueAction(stream, value);
|
|
}
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void SerializeList<T>(Stream stream, List<T> list) where T : struct
|
|
{
|
|
SerializeStructure<int>(stream, list.Count);
|
|
|
|
foreach (T item in list)
|
|
{
|
|
SerializeStructure<T>(stream, item);
|
|
}
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void SerializeStructure<T>(Stream stream, T structure) where T : struct
|
|
{
|
|
Span<T> spanT = MemoryMarshal.CreateSpan(ref structure, 1);
|
|
stream.Write(MemoryMarshal.AsBytes(spanT));
|
|
}
|
|
#endregion
|
|
|
|
#region "Extension methods"
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void ReadFrom<T>(this List<T[]> list, Stream stream) where T : struct
|
|
{
|
|
int count = DeserializeStructure<int>(stream);
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
int itemLength = DeserializeStructure<int>(stream);
|
|
|
|
T[] item = new T[itemLength];
|
|
|
|
int bytesCount = stream.Read(MemoryMarshal.AsBytes(item.AsSpan()));
|
|
|
|
if (bytesCount != itemLength)
|
|
{
|
|
throw new EndOfStreamException();
|
|
}
|
|
|
|
list.Add(item);
|
|
}
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static long Length<T>(this List<T[]> list) where T : struct
|
|
{
|
|
long size = 0L;
|
|
|
|
size += Unsafe.SizeOf<int>();
|
|
|
|
foreach (T[] item in list)
|
|
{
|
|
size += Unsafe.SizeOf<int>();
|
|
size += item.Length;
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void WriteTo<T>(this List<T[]> list, Stream stream) where T : struct
|
|
{
|
|
SerializeStructure<int>(stream, list.Count);
|
|
|
|
foreach (T[] item in list)
|
|
{
|
|
SerializeStructure<int>(stream, item.Length);
|
|
|
|
stream.Write(MemoryMarshal.AsBytes(item.AsSpan()));
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
} |