mxaccess/analysis/decompiled/aaServicesContractIData/ArchestrAServices.ASBContract/ItemIdentity.cs

#define TRACE
using System;
using System.CodeDom.Compiler;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Xml.Serialization;
using ArchestrAServices.Common;
using ArchestrAServices.Contract;

namespace ArchestrAServices.ASBContract;

[Serializable]
[GeneratedCode("System.Xml", "4.0.30319.18054")]
[DebuggerStepThrough]
[XmlType(Namespace = "http://asb.contracts.idata.data/20111111")]
public struct ItemIdentity : IASBCustomSerializableType
{
	private ushort typeField;

	private ushort referenceTypeField;

	private string nameField;

	private string contextNameField;

	private ulong idField;

	private bool idFieldSpecified;

	public ushort Type
	{
		get
		{
			return typeField;
		}
		set
		{
			typeField = value;
		}
	}

	public ushort ReferenceType
	{
		get
		{
			return referenceTypeField;
		}
		set
		{
			referenceTypeField = value;
		}
	}

	[XmlElement(IsNullable = true)]
	public string Name
	{
		get
		{
			return nameField;
		}
		set
		{
			nameField = value;
		}
	}

	[XmlElement(IsNullable = true)]
	public string ContextName
	{
		get
		{
			return contextNameField;
		}
		set
		{
			contextNameField = value;
		}
	}

	public ulong Id
	{
		get
		{
			return idField;
		}
		set
		{
			idField = value;
			IdSpecified = true;
		}
	}

	[XmlIgnore]
	public bool IdSpecified
	{
		get
		{
			return idFieldSpecified;
		}
		set
		{
			idFieldSpecified = value;
		}
	}

	public void WriteToStream(BinaryWriter writer)
	{
		if (writer == null)
		{
			return;
		}
		try
		{
			writer.Write(typeField);
			writer.Write(referenceTypeField);
			if (!string.IsNullOrEmpty(nameField))
			{
				byte[] bytes = Encoding.Unicode.GetBytes(nameField);
				writer.Write((uint)bytes.Length);
				writer.Write(bytes);
			}
			else
			{
				writer.Write(0u);
			}
			if (!string.IsNullOrEmpty(contextNameField))
			{
				byte[] bytes2 = Encoding.Unicode.GetBytes(contextNameField);
				writer.Write((uint)bytes2.Length);
				writer.Write(bytes2);
			}
			else
			{
				writer.Write(0u);
			}
			writer.Write(Id);
			writer.Write(IdSpecified);
		}
		catch (Exception ex)
		{
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Error, 0, $" ItemIdentity: WriteTo. Exception raised {ex.Message} \n Stack Trace: {ex.StackTrace}");
		}
	}

	public void InitializeFromStream(BinaryReader reader)
	{
		if (!MemoryStreamHelper.ValidateStream(reader))
		{
			return;
		}
		try
		{
			typeField = reader.ReadUInt16();
			referenceTypeField = reader.ReadUInt16();
			int num = reader.ReadInt32();
			if (num > 0)
			{
				byte[] bytes = reader.ReadBytes(num);
				nameField = Encoding.Unicode.GetString(bytes);
			}
			else
			{
				nameField = string.Empty;
			}
			num = reader.ReadInt32();
			if (num > 0)
			{
				byte[] bytes2 = reader.ReadBytes(num);
				contextNameField = Encoding.Unicode.GetString(bytes2);
			}
			else
			{
				contextNameField = string.Empty;
			}
			idField = reader.ReadUInt64();
			idFieldSpecified = reader.ReadBoolean();
		}
		catch (Exception ex)
		{
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Error, 0, $" ItemIdentity: InitializeFrom. Exception raised {ex.Message} \n Stack Trace: {ex.StackTrace}");
		}
	}

	public object InitializeArrayFromStream(BinaryReader reader, int arrayCnt)
	{
		object result = null;
		if (MemoryStreamHelper.ValidateStream(reader, arrayCnt))
		{
			try
			{
				ItemIdentity[] array = new ItemIdentity[arrayCnt];
				for (int i = 0; i < arrayCnt; i++)
				{
					InitializeFrom(reader, ref array[i]);
				}
				result = array;
			}
			catch (Exception ex)
			{
				SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Error, 0, $" ItemIdentity: InitializeFromArray. Exception raised {ex.Message} \n Stack Trace: {ex.StackTrace}");
			}
		}
		return result;
	}

	public void WriteArrayToStream(object graph, ref BinaryWriter bw)
	{
		if (graph == null || bw == null)
		{
			return;
		}
		try
		{
			if (graph is ItemIdentity[] array)
			{
				bw.Write(array.Length);
				ItemIdentity[] array2 = array;
				foreach (ItemIdentity itemIdentity in array2)
				{
					itemIdentity.WriteToStream(bw);
				}
			}
		}
		catch (Exception ex)
		{
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Error, 0, $" ItemIdentity: WriteArrayTo. Exception raised {ex.Message} \n Stack Trace: {ex.StackTrace}");
		}
	}

	private static void InitializeFrom(BinaryReader reader, ref ItemIdentity result)
	{
		if (MemoryStreamHelper.ValidateStream(reader))
		{
			result.typeField = reader.ReadUInt16();
			result.referenceTypeField = reader.ReadUInt16();
			int num = reader.ReadInt32();
			if (num > 0)
			{
				byte[] bytes = reader.ReadBytes(num);
				result.nameField = Encoding.Unicode.GetString(bytes);
			}
			else
			{
				result.nameField = string.Empty;
			}
			num = reader.ReadInt32();
			if (num > 0)
			{
				byte[] bytes2 = reader.ReadBytes(num);
				result.contextNameField = Encoding.Unicode.GetString(bytes2);
			}
			else
			{
				result.contextNameField = string.Empty;
			}
			result.idField = reader.ReadUInt64();
			result.idFieldSpecified = reader.ReadBoolean();
		}
	}
}