From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- .../Scripts/XMainClient/ProtoBuf/Serializer.cs | 268 +++++++++++++++++++++ 1 file changed, 268 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/ProtoBuf/Serializer.cs (limited to 'Client/Assets/Scripts/XMainClient/ProtoBuf/Serializer.cs') 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() + { + 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 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(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(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(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 instance) + { + TTo result; + using (MemoryStream memoryStream = new MemoryStream()) + { + Serializer.Serialize(memoryStream, instance); + memoryStream.Position = 0L; + result = Serializer.Deserialize(memoryStream); + } + return result; + } + + public static void PrepareSerializer() + { + } + + public static IEnumerable DeserializeItems(Stream source, PrefixStyle style, int fieldNumber) + { + return RuntimeTypeModel.Default.DeserializeItems(source, style, fieldNumber); + } + + public static T DeserializeWithLengthPrefix(Stream source, PrefixStyle style) + { + return Serializer.DeserializeWithLengthPrefix(source, style, 0); + } + + public static T DeserializeWithLengthPrefix(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(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(Stream destination, T instance, PrefixStyle style) + { + Serializer.SerializeWithLengthPrefix(destination, instance, style, 0); + } + + public static void SerializeWithLengthPrefix(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(); + } + } +} -- cgit v1.1-26-g67d0