#define TRACE
using System;
using System.CodeDom.Compiler;
using System.Diagnostics;
using System.IO;
using System.Xml.Serialization;
using ArchestrAServices.ASBIDataContract;
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 RuntimeValue : IASBCustomSerializableType
{
	private DateTime timestampField;

	private bool timestampFieldSpecified;

	private Variant valueField;

	private ASBStatus statusField;

	public DateTime Timestamp
	{
		get
		{
			return timestampField;
		}
		set
		{
			timestampField = value;
			TimestampSpecified = true;
		}
	}

	[XmlIgnore]
	public bool TimestampSpecified
	{
		get
		{
			return timestampFieldSpecified;
		}
		set
		{
			timestampFieldSpecified = value;
		}
	}

	public ArchestrAServices.ASBIDataContract.Variant Value
	{
		get
		{
			return new ArchestrAServices.ASBIDataContract.Variant
			{
				Type = valueField.Type,
				Length = valueField.Length,
				Payload = valueField.Payload
			};
		}
		set
		{
			valueField.Type = value.Type;
			valueField.Length = value.Length;
			valueField.Payload = value.Payload;
		}
	}

	public ASBStatus Status
	{
		get
		{
			return statusField;
		}
		set
		{
			statusField = value;
		}
	}

	public void WriteToStream(BinaryWriter writer)
	{
		if (writer != null)
		{
			try
			{
				writer.Write(timestampField.ToBinary());
				writer.Write(timestampFieldSpecified);
				valueField.WriteToStream(writer);
				statusField.WriteToStream(writer);
			}
			catch (Exception ex)
			{
				SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Error, 0, $" RuntimeValue: WriteTo. Exception raised {ex.Message} \n Stack Trace: {ex.StackTrace}");
			}
		}
	}

	public void InitializeFromStream(BinaryReader reader)
	{
		if (MemoryStreamHelper.ValidateStream(reader))
		{
			try
			{
				timestampField = DateTime.FromBinary(reader.ReadInt64());
				timestampFieldSpecified = reader.ReadBoolean();
				valueField.InitializeFromStream(reader);
				statusField.InitializeFromStream(reader);
			}
			catch (Exception ex)
			{
				SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Error, 0, $" RuntimeValue: 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
			{
				RuntimeValue[] array = new RuntimeValue[arrayCnt];
				for (int i = 0; i < arrayCnt; i++)
				{
					InitializeFrom(reader, ref array[i]);
				}
				result = array;
			}
			catch (Exception ex)
			{
				SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Error, 0, $" RuntimeValue: 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 RuntimeValue[] array)
			{
				bw.Write(array.Length);
				RuntimeValue[] array2 = array;
				foreach (RuntimeValue runtimeValue in array2)
				{
					runtimeValue.WriteToStream(bw);
				}
			}
		}
		catch (Exception ex)
		{
			SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Error, 0, $" RuntimeValue: WriteArrayTo. Exception raised {ex.Message} \n Stack Trace: {ex.StackTrace}");
		}
	}

	private static void InitializeFrom(BinaryReader reader, ref RuntimeValue result)
	{
		if (MemoryStreamHelper.ValidateStream(reader))
		{
			result.timestampField = DateTime.FromBinary(reader.ReadInt64());
			result.timestampFieldSpecified = reader.ReadBoolean();
			result.valueField.InitializeFromStream(reader);
			result.statusField.InitializeFromStream(reader);
		}
	}
}