mxaccess/analysis/decompiled/aaServicesCommonDataContracts/ArchestrAServices.Contract/ASBCustomSerializer.cs

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Xml;

namespace ArchestrAServices.Contract;

public class ASBCustomSerializer : XmlObjectSerializer
{
	protected string m_ASBPrefix = "ASB";

	protected Type m_Type;

	protected bool m_IsArray;

	protected bool m_IsCustomSerialization;

	protected XmlObjectSerializer m_FallbackSerializer;

	public ASBCustomSerializer(Type type, XmlObjectSerializer fallbackSerializer)
	{
		Type c = type;
		m_IsArray = false;
		if (null != type && type.IsArray)
		{
			m_IsArray = true;
			c = type.GetElementType();
		}
		m_Type = type;
		m_IsCustomSerialization = typeof(IASBCustomSerializableType).IsAssignableFrom(c);
		m_FallbackSerializer = fallbackSerializer;
	}

	public override bool IsStartObject(XmlDictionaryReader reader)
	{
		bool flag = false;
		if (m_IsCustomSerialization && reader != null)
		{
			return string.Compare(reader.LocalName, m_ASBPrefix, StringComparison.CurrentCultureIgnoreCase) == 0;
		}
		return m_FallbackSerializer.IsStartObject(reader);
	}

	public override object ReadObject(XmlDictionaryReader reader, bool verifyObjectName)
	{
		object obj = null;
		if (m_IsCustomSerialization && reader != null)
		{
			using MemoryStream memoryStream = new MemoryStream(reader.ReadElementContentAsBase64());
			if (memoryStream != null && memoryStream.Length > 0)
			{
				BinaryReader binaryReader = new BinaryReader(memoryStream);
				if (m_IsArray)
				{
					int num = binaryReader.ReadInt32();
					if (num > 0)
					{
						Type elementType = m_Type.GetElementType();
						if (null != elementType && Activator.CreateInstance(elementType) is IASBCustomSerializableType iASBCustomSerializableType)
						{
							obj = iASBCustomSerializableType.InitializeArrayFromStream(binaryReader, num);
						}
					}
				}
				else
				{
					obj = Activator.CreateInstance(m_Type);
					((IASBCustomSerializableType)obj).InitializeFromStream(binaryReader);
				}
			}
		}
		else
		{
			obj = m_FallbackSerializer.ReadObject(reader, verifyObjectName);
		}
		return obj;
	}

	public override void WriteEndObject(XmlDictionaryWriter writer)
	{
		if (m_IsCustomSerialization && writer != null)
		{
			writer.WriteEndElement();
		}
		else
		{
			m_FallbackSerializer.WriteEndObject(writer);
		}
	}

	public override void WriteObjectContent(XmlDictionaryWriter writer, object graph)
	{
		if (m_IsCustomSerialization && writer != null)
		{
			MemoryStream memoryStream = new MemoryStream();
			try
			{
				BinaryWriter bw = new BinaryWriter(memoryStream);
				if (m_IsArray)
				{
					if (graph != null)
					{
						Type elementType = m_Type.GetElementType();
						if (null != elementType && Activator.CreateInstance(elementType) is IASBCustomSerializableType iASBCustomSerializableType)
						{
							iASBCustomSerializableType.WriteArrayToStream(graph, ref bw);
						}
					}
				}
				else
				{
					((IASBCustomSerializableType)graph).WriteToStream(bw);
				}
				byte[] array = memoryStream.ToArray();
				writer.WriteBase64(array, 0, array.Length);
				return;
			}
			finally
			{
				memoryStream.Dispose();
			}
		}
		m_FallbackSerializer.WriteObjectContent(writer, graph);
	}

	public override void WriteStartObject(XmlDictionaryWriter writer, object graph)
	{
		if (m_IsCustomSerialization && writer != null)
		{
			writer.WriteStartElement(m_ASBPrefix);
		}
		else
		{
			m_FallbackSerializer.WriteStartObject(writer, graph);
		}
	}
}