diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/ProtoBuf/Serializer.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/ProtoBuf/Serializer.cs | 268 |
1 files changed, 268 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializer.cs b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializer.cs new file mode 100644 index 00000000..c80cdea0 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ProtoBuf/Serializer.cs @@ -0,0 +1,268 @@ +using System;
+using System.Collections.Generic;
+using System.IO;
+using ProtoBuf.Meta;
+
+namespace ProtoBuf
+{
+ public static class Serializer
+ {
+ private static bool useMultiThread = false;
+
+ public static bool isSkipProtoIgnore = false;
+
+ private const string ProtoBinaryField = "proto";
+
+ public const int ListItemTag = 1;
+
+ public static class NonGeneric
+ {
+ public static object DeepClone(object instance)
+ {
+ return (instance == null) ? null : RuntimeTypeModel.Default.DeepClone(instance);
+ }
+
+ public static void Serialize(Stream dest, object instance)
+ {
+ bool flag = instance != null;
+ if (flag)
+ {
+ RuntimeTypeModel.Default.Serialize(dest, instance);
+ }
+ }
+
+ public static object Deserialize(Type type, Stream source)
+ {
+ return RuntimeTypeModel.Default.Deserialize(source, null, type);
+ }
+
+ public static object Merge(Stream source, object instance)
+ {
+ bool flag = instance == null;
+ if (flag)
+ {
+ throw new ArgumentNullException("instance");
+ }
+ return RuntimeTypeModel.Default.Deserialize(source, instance, instance.GetType(), null);
+ }
+
+ public static void SerializeWithLengthPrefix(Stream destination, object instance, PrefixStyle style, int fieldNumber)
+ {
+ bool flag = instance == null;
+ if (flag)
+ {
+ throw new ArgumentNullException("instance");
+ }
+ RuntimeTypeModel @default = RuntimeTypeModel.Default;
+ @default.SerializeWithLengthPrefix(destination, instance, @default.MapType(instance.GetType()), style, fieldNumber);
+ }
+
+ public static bool TryDeserializeWithLengthPrefix(Stream source, PrefixStyle style, Serializer.TypeResolver resolver, out object value)
+ {
+ value = RuntimeTypeModel.Default.DeserializeWithLengthPrefix(source, null, null, style, 0, resolver);
+ return value != null;
+ }
+
+ public static bool CanSerialize(Type type)
+ {
+ return RuntimeTypeModel.Default.IsDefined(type);
+ }
+ }
+
+ public static class GlobalOptions
+ {
+ [Obsolete("Please use RuntimeTypeModel.Default.InferTagFromNameDefault instead (or on a per-model basis)", false)]
+ public static bool InferTagFromName
+ {
+ get
+ {
+ return RuntimeTypeModel.Default.InferTagFromNameDefault;
+ }
+ set
+ {
+ RuntimeTypeModel.Default.InferTagFromNameDefault = value;
+ }
+ }
+ }
+
+ public delegate Type TypeResolver(int fieldNumber);
+
+ public static string GetProto<T>()
+ {
+ return RuntimeTypeModel.Default.GetSchema(RuntimeTypeModel.Default.MapType(typeof(T)));
+ }
+
+ public static void SetMultiThread(bool multiThread)
+ {
+ Serializer.useMultiThread = multiThread;
+ }
+
+ public static void SetSkipProtoIgnore(bool skipProtoIgnore)
+ {
+ Serializer.isSkipProtoIgnore = skipProtoIgnore;
+ }
+
+ public static T DeepClone<T>(T instance)
+ {
+ bool flag = instance == null;
+ T result;
+ if (flag)
+ {
+ result = instance;
+ }
+ else
+ {
+ bool flag2 = Serializer.useMultiThread;
+ if (flag2)
+ {
+ RuntimeTypeModel @default = RuntimeTypeModel.Default;
+ RuntimeTypeModel obj = @default;
+ lock (obj)
+ {
+ return (T)((object)@default.DeepClone(instance));
+ }
+ }
+ result = (T)((object)RuntimeTypeModel.Default.DeepClone(instance));
+ }
+ return result;
+ }
+
+ public static T Merge<T>(Stream source, T instance)
+ {
+ bool flag = Serializer.useMultiThread;
+ if (flag)
+ {
+ RuntimeTypeModel @default = RuntimeTypeModel.Default;
+ RuntimeTypeModel obj = @default;
+ lock (obj)
+ {
+ return (T)((object)@default.Deserialize(source, instance, typeof(T)));
+ }
+ }
+ return (T)((object)RuntimeTypeModel.Default.Deserialize(source, instance, typeof(T)));
+ }
+
+ public static T Deserialize<T>(Stream source)
+ {
+ bool flag = Serializer.useMultiThread;
+ if (flag)
+ {
+ RuntimeTypeModel @default = RuntimeTypeModel.Default;
+ RuntimeTypeModel obj = @default;
+ lock (obj)
+ {
+ return (T)((object)@default.Deserialize(source, null, typeof(T)));
+ }
+ }
+ return (T)((object)RuntimeTypeModel.Default.Deserialize(source, null, typeof(T)));
+ }
+
+ public static void Serialize<T>(Stream destination, T instance)
+ {
+ bool flag = instance != null;
+ if (flag)
+ {
+ bool flag2 = Serializer.useMultiThread;
+ if (flag2)
+ {
+ RuntimeTypeModel @default = RuntimeTypeModel.Default;
+ RuntimeTypeModel obj = @default;
+ lock (obj)
+ {
+ @default.Serialize(destination, instance);
+ }
+ }
+ else
+ {
+ RuntimeTypeModel.Default.Serialize(destination, instance);
+ }
+ }
+ }
+
+ public static void Clear()
+ {
+ bool flag = Serializer.useMultiThread;
+ if (flag)
+ {
+ RuntimeTypeModel @default = RuntimeTypeModel.Default;
+ RuntimeTypeModel obj = @default;
+ lock (obj)
+ {
+ RuntimeTypeModel.Default.Clear();
+ }
+ }
+ }
+
+ public static TTo ChangeType<TFrom, TTo>(TFrom instance)
+ {
+ TTo result;
+ using (MemoryStream memoryStream = new MemoryStream())
+ {
+ Serializer.Serialize<TFrom>(memoryStream, instance);
+ memoryStream.Position = 0L;
+ result = Serializer.Deserialize<TTo>(memoryStream);
+ }
+ return result;
+ }
+
+ public static void PrepareSerializer<T>()
+ {
+ }
+
+ public static IEnumerable<T> DeserializeItems<T>(Stream source, PrefixStyle style, int fieldNumber)
+ {
+ return RuntimeTypeModel.Default.DeserializeItems<T>(source, style, fieldNumber);
+ }
+
+ public static T DeserializeWithLengthPrefix<T>(Stream source, PrefixStyle style)
+ {
+ return Serializer.DeserializeWithLengthPrefix<T>(source, style, 0);
+ }
+
+ public static T DeserializeWithLengthPrefix<T>(Stream source, PrefixStyle style, int fieldNumber)
+ {
+ RuntimeTypeModel @default = RuntimeTypeModel.Default;
+ return (T)((object)@default.DeserializeWithLengthPrefix(source, null, @default.MapType(typeof(T)), style, fieldNumber));
+ }
+
+ public static T MergeWithLengthPrefix<T>(Stream source, T instance, PrefixStyle style)
+ {
+ RuntimeTypeModel @default = RuntimeTypeModel.Default;
+ return (T)((object)@default.DeserializeWithLengthPrefix(source, instance, @default.MapType(typeof(T)), style, 0));
+ }
+
+ public static void SerializeWithLengthPrefix<T>(Stream destination, T instance, PrefixStyle style)
+ {
+ Serializer.SerializeWithLengthPrefix<T>(destination, instance, style, 0);
+ }
+
+ public static void SerializeWithLengthPrefix<T>(Stream destination, T instance, PrefixStyle style, int fieldNumber)
+ {
+ RuntimeTypeModel @default = RuntimeTypeModel.Default;
+ @default.SerializeWithLengthPrefix(destination, instance, @default.MapType(typeof(T)), style, fieldNumber);
+ }
+
+ public static bool TryReadLengthPrefix(Stream source, PrefixStyle style, out int length)
+ {
+ int num;
+ int num2;
+ length = ProtoReader.ReadLengthPrefix(source, false, style, out num, out num2);
+ return num2 > 0;
+ }
+
+ public static bool TryReadLengthPrefix(byte[] buffer, int index, int count, PrefixStyle style, out int length)
+ {
+ bool result;
+ using (Stream stream = new MemoryStream(buffer, index, count))
+ {
+ result = Serializer.TryReadLengthPrefix(stream, style, out length);
+ }
+ return result;
+ }
+
+ public static void FlushPool()
+ {
+ BufferPool.Flush();
+ }
+ }
+}
|