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