public static void Deserialize(Test t, IBinaryReader reader)
{
t.Value = reader.Read <int>();
var isNotNullByte = reader.Read <byte>();
if (isNotNullByte == 1)
{
t.Nested = reader.ReadObject <Test>();
}
}
object IBinaryConverter.ReadBinary(IBinaryReader reader, SerializeMetadata context, IHolySerializer serializer)
{
var array = reader.Read(context.Length, context.IsReverse);
var encoding = (context == null || string.IsNullOrWhiteSpace(context.Options)) ? Encoding.UTF8 : Encoding.GetEncoding(context.Options);
return(encoding.GetString(array).TrimEnd('\0'));
}
private OperationData Map(TLG tlg, int?prescrptionId, string datacardPath, Dictionary <string, List <UniqueId> > linkedIds)
{
var tim = _xmlReader.ReadTlgXmlData(datacardPath, tlg.A + ".xml").First();
var isoRecords = _binaryReader.Read(datacardPath, tlg.A + ".bin", tim).ToList();
var sections = _sectionMapper.Map(new List <TIM> {
tim
}, isoRecords);
var meters = sections != null?sections.SelectMany(x => x.GetWorkingDatas()).ToList() : new List <WorkingData>();
var operationData = new OperationData
{
GetSpatialRecords = () => _spatialRecordMapper.Map(isoRecords, meters),
MaxDepth = 0,
GetDeviceElementUses = x => x == 0 ? sections : new List <DeviceElementUse>(),
PrescriptionId = prescrptionId
};
operationData.Id.UniqueIds.Add(_uniqueIdMapper.Map(tlg.A));
if (linkedIds.ContainsKey(tlg.A))
{
foreach (var linkedId in linkedIds[tlg.A])
{
operationData.Id.UniqueIds.Add(linkedId);
}
}
return(operationData);
}
/// <summary>
/// Writes <paramref name="reader"/>, starting at <paramref name="reader"/>'s current
/// position, to <paramref name="writer"/> starting at <paramref name="writer"/>'s
/// current position. Returns the number of bytes written.
/// </summary>
/// <param name="reader">Reader</param>
/// <param name="writer">Writer</param>
/// <param name="dataBuffer">Temp buffer during writing</param>
/// <returns>Number of bytes written</returns>
/// <exception cref="IOException">Could not write all bytes or data is too big</exception>
public static uint WriteTo(this IBinaryReader reader, BinaryWriter writer, byte[] dataBuffer)
{
if (reader.Position >= reader.Length)
{
return(0);
}
long longLenLeft = reader.Length - reader.Position;
if (longLenLeft > uint.MaxValue)
{
throw new IOException("Data is too big");
}
uint lenLeft = (uint)longLenLeft;
uint writtenBytes = lenLeft;
while (lenLeft > 0)
{
int num = (int)Math.Min((uint)dataBuffer.Length, lenLeft);
lenLeft -= (uint)num;
if (num != reader.Read(dataBuffer, 0, num))
{
throw new IOException("Could not read all reader bytes");
}
writer.Write(dataBuffer, 0, num);
}
return(writtenBytes);
}
public void Deserialize(IBinaryReader reader)
{
Name = reader.ReadShortUTF();
Method = reader.ReadShortUTF();
int count = reader.ReadInt16();
RInterfaceInfo interfaceinfo = null;
RMethodInfo methodinfo = null;
if (RInterfaceFactory.Default.TryGet(Name, out interfaceinfo) && interfaceinfo.TryGet(Method, out methodinfo) && methodinfo.Parameters.Count == count)
{
Parameters = new object[count];
for (int i = 0; i < count; i++)
{
int size = reader.ReadInt32();
if (size > 0)
{
Parameters[i] = reader.Stream.Deserialize(size, methodinfo.Parameters[i].Type);
}
}
}
else
{
for (int i = 0; i < count; i++)
{
int size = reader.ReadInt32();
byte[] data = new byte[size];
reader.Read(data, 0, size);
}
DeserializeError = string.Format("{0}.{1} method not found!", Name, Method);
}
}
public static T Read <T> (this IBinaryReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
return((T)reader.Read(typeof(T)) !);
}
private static bool TryReadByteWithoutSeeking(this IBinaryReader reader, out byte value)
{
try
{
value = reader.Read <byte> ( );
return(true);
}
catch (EndOfStreamException)
{
value = default;
return(false);
}
}
public static short GetArgIndex(OpCode opCode, IBinaryReader binaryReader)
{
if (opCode == OpCodes.Ldarg || opCode == OpCodes.Starg || opCode == OpCodes.Ldarga)
{
return(System.BitConverter.ToInt16(binaryReader.Read(binaryReader.Offset - 2, 2), 0));
}
if (opCode == OpCodes.Ldarg_0)
{
return(0); // this
}
if (opCode == OpCodes.Ldarg_1)
{
return(1);
}
if (opCode == OpCodes.Ldarg_2)
{
return(2);
}
if (opCode == OpCodes.Ldarg_3)
{
return(3);
}
return(binaryReader.Read(binaryReader.Offset - 1, 1)[0]);
}
public static short GetLocalIndex(OpCode opCode, IBinaryReader binaryReader)
{
if (opCode == OpCodes.Ldloc || opCode == OpCodes.Stloc || opCode == OpCodes.Ldloca)
{
return(System.BitConverter.ToInt16(binaryReader.Read(binaryReader.Offset - 2, 2), 0));
}
if (opCode == OpCodes.Ldloc_0 || opCode == OpCodes.Stloc_0)
{
return(0);
}
if (opCode == OpCodes.Ldloc_1 || opCode == OpCodes.Stloc_1)
{
return(1);
}
if (opCode == OpCodes.Ldloc_2 || opCode == OpCodes.Stloc_2)
{
return(2);
}
if (opCode == OpCodes.Ldloc_3 || opCode == OpCodes.Stloc_3)
{
return(3);
}
return(binaryReader.Read(binaryReader.Offset - 1, 1)[0]);
}
public static bool ReadTo(IBinaryReader reader, byte[] buffer, int offset, int count, out int read)
{
int start = offset;
while ((read = reader.Read(buffer, offset, count)) > 0)
{
if (read == count)
{
read = count;
return(true);
}
offset += read;
count -= read;
}
read = offset - start;
return(false);
}
internal Instruction(int index, IBinaryReader binaryReader, Context.IOperandReaderContext context)
{
this.Index = index;
this.Offset = binaryReader.Offset;
this.OpCode = OpCodeReader.ReadOpCode(binaryReader);
// Operand
bool argumentAware = OperandReader.IsArgumentAware(OpCode);
if (argumentAware)
{
this.Operand = OperandReader.ReadArg(binaryReader, context, OpCode.OperandType);
argIndex = OperandReader.GetArgIndex(OpCode, binaryReader);
if (argIndex.Value > 0)
{
this.rawOperand = context[(short)(argIndex.Value - 1), true];
}
else
{
this.rawOperand = context.This;
}
}
bool localAware = OperandReader.IsLocalAware(OpCode);
if (localAware)
{
this.Operand = OperandReader.Read(binaryReader, context, OpCode.OperandType);
locIndex = OperandReader.GetLocalIndex(OpCode, binaryReader);
if (Operand == null)
{
this.rawOperand = context[locIndex.Value, false];
}
}
if (!localAware && !argumentAware)
{
this.Operand = OperandReader.Read(binaryReader, context, OpCode.OperandType);
}
//
int size = binaryReader.Offset - Offset;
this.bytes = new LazyRef <byte[]>(() => binaryReader.Read(Offset, size));
}
object IBinaryConverter.ReadBinary(IBinaryReader reader, SerializeMetadata context, IHolySerializer serializer)
{
var array = reader.Read(context.Length == 0 ? reader.ReadRemainderLength() : context.Length, context.IsReverse);
var value = Activator.CreateInstance(context.ObjectType);
var childReader = serializer.ReaderCreator.Create(array);
context.Childs.ForEach(b =>
{
foreach (var c in serializer.Converters)
{
if (c.CanConvert(b))
{
var val = c.ReadBinary(childReader, b, serializer);
HelperExtension.SetValue(b.Name, value, new object[] { val });
break;
}
}
;
});
return(value);
}
public static bool TryReadByte(this IBinaryReader reader, out byte value)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
if (reader is IStreamBinaryReader streamReader && streamReader.BaseStream.CanSeek)
{
if (streamReader.BaseStream.Position == streamReader.BaseStream.Length)
{
value = default;
return(false);
}
value = reader.Read <byte> ( );
return(true);
}
return(reader.TryReadByteWithoutSeeking(out value));
}
public static void Deserialize(TestWithConstructor t, IBinaryReader reader)
{
t.Value.Should().Be(0);
t.Value = reader.Read <int>();
}
object IBinaryConverter.ReadBinary(IBinaryReader reader, SerializeMetadata context, IHolySerializer serializer)
{
var array = reader.Read(context.Length, context.IsReverse);
return(array);
}
private IEnumerable<HgChunk> ReadBundleGroup(IBinaryReader binaryReader)
{
const uint nullChunkMaxSize = 4;
const int chunkHeaderSize = 84;
uint length;
while((length = binaryReader.ReadUInt32()) > nullChunkMaxSize)
{
var nodeID = new HgNodeID(binaryReader.ReadBytes(20));
var firstParentNodeID = new HgNodeID(binaryReader.ReadBytes(20));
var secondParentNodeID = new HgNodeID(binaryReader.ReadBytes(20));
var changesetNodeID = new HgNodeID(binaryReader.ReadBytes(20));
var dataLength = (int)length - chunkHeaderSize;
var data = new byte[dataLength];
binaryReader.Read(data, 0, dataLength);
var chunk = new HgChunk(nodeID, firstParentNodeID, secondParentNodeID, changesetNodeID, data);
yield return chunk;
} // while
}
public static void Deserialize(Test t, IBinaryReader reader)
{
t.Value = reader.Read <int>();
}
/// <inheritdoc/>
public override int Read(byte[] buffer, int offset, int count)
{
return(reader.Read(buffer, offset, count));
}
object IBinaryConverter.ReadBinary(IBinaryReader reader, SerializeMetadata context, IHolySerializer serializer)
{
var array = reader.Read(context.Length, context.IsReverse);
object value = null;
switch (Type.GetTypeCode(context.ObjectType))
{
case TypeCode.Boolean:
value = BitConverter.ToBoolean(array, 0);
break;
case TypeCode.Byte:
value = array[0];
break;
case TypeCode.Char:
value = BitConverter.ToChar(array, 0);
break;
case TypeCode.DBNull:
break;
case TypeCode.DateTime:
value = new DateTime(BitConverter.ToInt64(array, 0));
break;
case TypeCode.Decimal:
{
if (array.Count() != 16)
{
throw new Exception("A decimal must be created from exactly 16 bytes");
}
var bits = new Int32[4];
for (int i = 0; i <= 15; i += 4)
{
bits[i / 4] = BitConverter.ToInt32(array, i);
}
value = new decimal(bits);
}
break;
case TypeCode.Double:
value = BitConverter.ToDouble(array, 0);
break;
case TypeCode.Empty:
break;
case TypeCode.Int16:
value = BitConverter.ToInt16(array, 0);
break;
case TypeCode.Int32:
value = BitConverter.ToInt32(array, 0);
break;
case TypeCode.Int64:
value = BitConverter.ToInt64(array, 0);
break;
case TypeCode.SByte:
value = (sbyte)array[0];
break;
case TypeCode.Single:
value = BitConverter.ToSingle(array, 0);
break;
case TypeCode.UInt16:
value = BitConverter.ToUInt16(array, 0);
break;
case TypeCode.UInt32:
value = BitConverter.ToUInt32(array, 0);
break;
case TypeCode.UInt64:
value = BitConverter.ToUInt64(array, 0);
break;
default:
break;
}
return(value);
}
