Move solution and projects to src

src/ARMeilleure/Translation/PTC/PtcFormatter.cs

@@ -0,0 +1,179 @@
+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
+    }
+}