PURErat-crack-scode/decompiled/PanelPlugins/PureHelper.Client/ProtoBuf/Serializer.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization;
using System.Xml;
using System.Xml.Serialization;
using ProtoBuf.Meta;

namespace ProtoBuf;

public static class Serializer
{
	public static class NonGeneric
	{
		public static object DeepClone(object instance)
		{
			if (instance != null)
			{
				return RuntimeTypeModel.Default.DeepClone(instance);
			}
			return null;
		}

		public static void Serialize(Stream dest, object instance)
		{
			if (instance != null)
			{
				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)
		{
			if (instance == null)
			{
				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)
		{
			if (instance == null)
			{
				throw new ArgumentNullException("instance");
			}
			RuntimeTypeModel runtimeTypeModel = RuntimeTypeModel.Default;
			runtimeTypeModel.SerializeWithLengthPrefix(destination, instance, runtimeTypeModel.MapType(instance.GetType()), style, fieldNumber);
		}

		public static bool TryDeserializeWithLengthPrefix(Stream source, PrefixStyle style, 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 void PrepareSerializer(Type t)
		{
			RuntimeTypeModel runtimeTypeModel = RuntimeTypeModel.Default;
			runtimeTypeModel[runtimeTypeModel.MapType(t)].CompileInPlace();
		}
	}

	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);

	private const string ProtoBinaryField = "proto";

	public const int ListItemTag = 1;

	public static string GetProto<T>()
	{
		return GetProto<T>(ProtoSyntax.Proto2);
	}

	public static string GetProto<T>(ProtoSyntax syntax)
	{
		return RuntimeTypeModel.Default.GetSchema(RuntimeTypeModel.Default.MapType(typeof(T)), syntax);
	}

	public static T DeepClone<T>(T instance)
	{
		if (instance != null)
		{
			return (T)RuntimeTypeModel.Default.DeepClone(instance);
		}
		return instance;
	}

	public static T Merge<T>(Stream source, T instance)
	{
		return (T)RuntimeTypeModel.Default.Deserialize(source, instance, typeof(T));
	}

	public static T Deserialize<T>(Stream source)
	{
		return (T)RuntimeTypeModel.Default.Deserialize(source, null, typeof(T));
	}

	public static object Deserialize(Type type, Stream source)
	{
		return RuntimeTypeModel.Default.Deserialize(source, null, type);
	}

	public static void Serialize<T>(Stream destination, T instance)
	{
		if (instance != null)
		{
			RuntimeTypeModel.Default.Serialize(destination, instance);
		}
	}

	public static TTo ChangeType<TFrom, TTo>(TFrom instance)
	{
		using MemoryStream memoryStream = new MemoryStream();
		Serialize((Stream)memoryStream, instance);
		memoryStream.Position = 0L;
		return Deserialize<TTo>(memoryStream);
	}

	public static void Serialize<T>(SerializationInfo info, T instance) where T : class, ISerializable
	{
		Serialize(info, new StreamingContext(StreamingContextStates.Persistence), instance);
	}

	public static void Serialize<T>(SerializationInfo info, StreamingContext context, T instance) where T : class, ISerializable
	{
		if (info == null)
		{
			throw new ArgumentNullException("info");
		}
		if (instance == null)
		{
			throw new ArgumentNullException("instance");
		}
		if ((object)instance.GetType() != typeof(T))
		{
			throw new ArgumentException("Incorrect type", "instance");
		}
		using MemoryStream memoryStream = new MemoryStream();
		RuntimeTypeModel.Default.Serialize(memoryStream, instance, context);
		info.AddValue("proto", memoryStream.ToArray());
	}

	public static void Serialize<T>(XmlWriter writer, T instance) where T : IXmlSerializable
	{
		if (writer == null)
		{
			throw new ArgumentNullException("writer");
		}
		if (instance == null)
		{
			throw new ArgumentNullException("instance");
		}
		using MemoryStream memoryStream = new MemoryStream();
		Serialize((Stream)memoryStream, instance);
		writer.WriteBase64(Helpers.GetBuffer(memoryStream), 0, (int)memoryStream.Length);
	}

	public static void Merge<T>(XmlReader reader, T instance) where T : IXmlSerializable
	{
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Invalid comparison between Unknown and I4
		if (reader == null)
		{
			throw new ArgumentNullException("reader");
		}
		if (instance == null)
		{
			throw new ArgumentNullException("instance");
		}
		byte[] array = new byte[4096];
		using MemoryStream memoryStream = new MemoryStream();
		int depth = reader.Depth;
		while (reader.Read() && reader.Depth > depth)
		{
			if ((int)reader.NodeType == 3)
			{
				int count;
				while ((count = reader.ReadContentAsBase64(array, 0, 4096)) > 0)
				{
					memoryStream.Write(array, 0, count);
				}
				if (reader.Depth <= depth)
				{
					break;
				}
			}
		}
		memoryStream.Position = 0L;
		Merge((Stream)memoryStream, instance);
	}

	public static void Merge<T>(SerializationInfo info, T instance) where T : class, ISerializable
	{
		Merge(info, new StreamingContext(StreamingContextStates.Persistence), instance);
	}

	public static void Merge<T>(SerializationInfo info, StreamingContext context, T instance) where T : class, ISerializable
	{
		if (info == null)
		{
			throw new ArgumentNullException("info");
		}
		if (instance == null)
		{
			throw new ArgumentNullException("instance");
		}
		if ((object)instance.GetType() != typeof(T))
		{
			throw new ArgumentException("Incorrect type", "instance");
		}
		byte[] buffer = (byte[])info.GetValue("proto", typeof(byte[]));
		using MemoryStream source = new MemoryStream(buffer);
		T val = (T)RuntimeTypeModel.Default.Deserialize(source, instance, typeof(T), context);
		if (val != instance)
		{
			throw new ProtoException("Deserialization changed the instance; cannot succeed.");
		}
	}

	public static void PrepareSerializer<T>()
	{
		NonGeneric.PrepareSerializer(typeof(T));
	}

	public static IFormatter CreateFormatter<T>()
	{
		return RuntimeTypeModel.Default.CreateFormatter(typeof(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 DeserializeWithLengthPrefix<T>(source, style, 0);
	}

	public static T DeserializeWithLengthPrefix<T>(Stream source, PrefixStyle style, int fieldNumber)
	{
		RuntimeTypeModel runtimeTypeModel = RuntimeTypeModel.Default;
		return (T)runtimeTypeModel.DeserializeWithLengthPrefix(source, null, runtimeTypeModel.MapType(typeof(T)), style, fieldNumber);
	}

	public static T MergeWithLengthPrefix<T>(Stream source, T instance, PrefixStyle style)
	{
		RuntimeTypeModel runtimeTypeModel = RuntimeTypeModel.Default;
		return (T)runtimeTypeModel.DeserializeWithLengthPrefix(source, instance, runtimeTypeModel.MapType(typeof(T)), style, 0);
	}

	public static void SerializeWithLengthPrefix<T>(Stream destination, T instance, PrefixStyle style)
	{
		SerializeWithLengthPrefix(destination, instance, style, 0);
	}

	public static void SerializeWithLengthPrefix<T>(Stream destination, T instance, PrefixStyle style, int fieldNumber)
	{
		RuntimeTypeModel runtimeTypeModel = RuntimeTypeModel.Default;
		runtimeTypeModel.SerializeWithLengthPrefix(destination, instance, runtimeTypeModel.MapType(typeof(T)), style, fieldNumber);
	}

	public static bool TryReadLengthPrefix(Stream source, PrefixStyle style, out int length)
	{
		length = ProtoReader.ReadLengthPrefix(source, expectHeader: false, style, out var _, out var bytesRead);
		return bytesRead > 0;
	}

	public static bool TryReadLengthPrefix(byte[] buffer, int index, int count, PrefixStyle style, out int length)
	{
		using Stream source = new MemoryStream(buffer, index, count);
		return TryReadLengthPrefix(source, style, out length);
	}

	public static void FlushPool()
	{
		BufferPool.Flush();
	}
}