public virtual object ReadType(string typeName, Configuration configuration, BinaryContext context) { var typeDescription = configuration.Descriptions.Find(p => p.Name.Equals(typeName)); if (typeDescription == null) throw new ArgumentException("The complex type " + typeName + " was not found in configuration"); try { var type=Type.GetType(typeDescription.ClassName); if (type==null) { throw new InvalidOperationException("Specified type was not found in classpath"); } var result=Activator.CreateInstance(type); foreach (var fieldDescription in typeDescription.Fields) { var typeReader = TypeReaderFactory.GetTypeReader(fieldDescription.Type,configuration); var fieldValue = typeReader.ReadType(fieldDescription.Type, configuration, context); type.GetProperty(fieldDescription.Name).GetSetMethod().Invoke(result,new[] {fieldValue}); } return result; } catch (Exception exception) { throw new InvalidOperationException("Cannot read type " + typeDescription.ClassName + " from given context", exception); } }
public void InitTest() { var configurationSerializerBase = new ConfigurationSerializerBase(); _context = new BinaryContext(); _configuration = configurationSerializerBase.Deserialize("TCPDescription.xml"); _context.InitializeFromFile("HttpPackage.dat"); CreateResultPackage(); }
public void TestSplitting() { Configuration configuration = _configurationSerializer.Deserialize("description.xml"); BinaryContext context = new BinaryContext(); context.InitializeFromFile("BinaryRecords.dat"); var result=_splitter.Split(configuration, context); Assert.IsTrue(CompareObjects(result, _verificationObject),"The splitted object differs from the expected one"); }
protected static void CheckConfigurationAndContext(Configuration configuration, BinaryContext context) { if(configuration==null) { throw new ArgumentException("Configuration is null"); } if (context==null || !context.IsInitialized()) { throw new ArgumentException("Context is null or not initialized"); } }
protected override string DetermineNextTypeName(Configuration configuration, BinaryContext context) { CreateReaderFactory(); string typeName = _typeNames[_currentTypeName]; _currentTypeName++; if (_currentTypeName>=_typeNames.Length) { _repeatCounter++; _currentTypeName = 0; } return typeName; }
private object ReadByte(BinaryContext context) { try { var _byte = context.ReadByte(); return _byte; } catch (Exception exception) { throw new InvalidOperationException("Cannot read byte from given context", exception); } }
private object ReadChar(BinaryContext context) { try { var bytes = context.ReadBytes(2); Array.Reverse(bytes); return BitConverter.ToChar(bytes, 0); } catch (Exception exception) { throw new InvalidOperationException("Cannot read char from given context", exception); } }
public List<Object> ReadObjects(Configuration configuration, BinaryContext context) { CheckConfigurationAndContext(configuration,context); var objects = new List<object>(); while (!EndReading(configuration, context, objects)) { var typeName = DetermineNextTypeName(configuration, context); var typeReader = ReaderFactory.GetTypeReader(typeName, configuration); var result = typeReader.ReadType(typeName, configuration, context); objects.Add(result); } return objects; }
protected override string DetermineNextTypeName(Configuration configuration, BinaryContext context) { CreateTypeReaderFactory(configuration,context); long markerSize = GetMarkerSize(configuration, context); if (!context.CanReadBytes(markerSize)) { throw new InvalidOperationException("Unable to read next type marker from context"); } var markerBytes = context.PeekBytes(markerSize); var nextType = FindTypeForMarker(configuration, markerBytes); _typesCounter++; return nextType; }
public object ReadType(string typeName, Configuration configuration, BinaryContext context) { string elementTypeName; uint arrayLength = GetArrayLength(typeName, out elementTypeName); var typeReader = TypeReaderFactory.GetTypeReader(elementTypeName, configuration); var result = new object[arrayLength]; for (var i = 0; i < result.Length; i++) { result[i] = typeReader.ReadType(elementTypeName, configuration, context); } var typeCastedResult = CreateTypeCastedArray(result); return typeCastedResult; }
public List<byte[]> Split(long sizeOffset, long sizeLength, BinaryContext context) { var result = new List<byte[]>(); while (!context.EndOfContextReached()) { var sizeValue = context.PeekBytes(sizeOffset, sizeLength); var size = ConvertSize(sizeValue); if (context.CanReadBytes(size)) { result.Add(context.ReadBytes(size)); } else throw new EndOfStreamException("Cannot read next block of size " + size); } return result; }
public List<Object> ReadObjects(Configuration configuration, BinaryContext context) { CheckConfigurationAndContext(configuration,context); var objects = new List<object>(); var splitter = GetSplitter(); var splittedResult = splitter.Split(configuration, context); var subContext = new BinaryContext(); foreach (var splittedData in splittedResult) { subContext.InitializeFromArray(splittedData); var result = ReadObjectsFromSubContext(configuration, subContext, objects); objects.Add(result); } return objects; }
private byte[] RetrieveMarker(Configuration configuration, BinaryContext context) { byte[] result = null; var marker = configuration.Metadata.Find(p => p.MetadataType == MetadataTypes.RecordSeparatingMarker); if (marker is OffsetMetadata) { var offsetMarker = (OffsetMetadata) marker; result = context.PeekBytes(offsetMarker.Offset, offsetMarker.Length); } if (marker is ValueMetadata) { var valueMarker = (ValueMetadata) marker; result = ConvertToBytes(valueMarker.Value); } if (result != null) return result; throw new InvalidOperationException("Cannot determine the record marker"); }
protected long GetMarkerSize(Configuration configuration, BinaryContext context) { long markerSize; MetadataBase markerSizeMetadata = configuration.Metadata.Find(p => p.MetadataType == MetadataTypes.TypeMarkerSize); if (markerSizeMetadata is ValueMetadata) { markerSize = Int64.Parse(((ValueMetadata) markerSizeMetadata).Value); } else { var offsetMetadata = (OffsetMetadata) markerSizeMetadata; byte[] sizeBytes = context.PeekBytes(offsetMetadata.Offset, offsetMetadata.Length); markerSize = ConvertSize(sizeBytes); } return markerSize; }
/// <summary> /// Splits the given context to several data arrays using the global RecordSize metadata. /// </summary> /// <param name="configuration">the configuration to use</param> /// <param name="context">the binary context to work with</param> /// <returns>the result of splitting.</returns> public List<byte[]> Split(Configuration configuration, BinaryContext context) { var globalSizeMetadata = configuration.Metadata.Single(p => p.MetadataType == MetadataTypes.RecordSize); if(globalSizeMetadata is OffsetMetadata) { var offsetMetadata = globalSizeMetadata as OffsetMetadata; var result=_offsetSizeDataSplitter.Split(offsetMetadata.Offset, offsetMetadata.Length, context); return result; } if (globalSizeMetadata is ValueMetadata) { var valueMetadata = globalSizeMetadata as ValueMetadata; var result = _valueSizeDataSplitter.Split(Int64.Parse(valueMetadata.Value), context); return result; } throw new InvalidOperationException("Cannot determine size metadata type:"); }
public object ReadType(string typeName, Configuration configuration, BinaryContext context) { object result; switch (typeName) { case "byte": result = ReadByte(context); break; case "char": result = ReadChar(context); break; case "double": result = ReadDouble(context); break; case "float": case "single": result = ReadFloat(context); break; case "long": result = ReadLong(context); break; case "short": result = ReadShort(context); break; case "string": result = ReadString(context); break; case "int": result = ReadInt(context); break; case "ulong": result = ReadULong(context); break; case "ushort": result = ReadUShort(context); break; case "uint": result = ReadUInt(context); break; default: throw new ArgumentException("Unknown simple type: "+typeName, typeName); } return result; }
/// <summary> /// Splits the given context to several data arrays using the global RecordMarker metadata. /// </summary> /// <param name="configuration">the configuration to use</param> /// <param name="context">the binary context to work with</param> /// <returns>the result of splitting.</returns> public List<byte[]> Split(Configuration configuration, BinaryContext context) { var result = new List<byte[]>(); byte[] marker = RetrieveMarker(configuration, context); var positions=context.FindMarkers(marker); for (int i = 0; i < positions.Count; i++) { var index = positions[i]; var prevIndex = (i-1<0)?0:positions[i - 1]; var recordSize = index - prevIndex; if(context.CanReadBytes(recordSize+marker.Length)) { } } return result; }
private object ReadString(BinaryContext context) { try { var str = ""; var bytes = context.ReadBytes(2); var ch = BitConverter.ToChar(bytes, 0); while (ch != '\0') { str = str + ch; bytes = context.ReadBytes(2); ch = BitConverter.ToChar(bytes, 0); } return str; } catch (Exception exception) { throw new InvalidOperationException("Cannot read string from given context", exception); } }
public List<byte[]> Split(long sizeValue, BinaryContext context) { var result = new List<byte[]>(); while (!context.EndOfContextReached()) { if (context.CanReadBytes(sizeValue)) { result.Add(context.ReadBytes(sizeValue)); } else throw new EndOfStreamException("Cannot read next block of size " + sizeValue); } return result; }
public override object ReadType(string typeName, Configuration configuration, BinaryContext context) { context.MoveForward(_markerSize); return base.ReadType(typeName, configuration, context); }
protected abstract object[] ReadObjectsFromSubContext(Configuration configuration, BinaryContext context, List<Object> objects);
protected override bool EndReading(Configuration configuration, BinaryContext context, List<object> objects) { return (_currentTypeName >= _typeNames.Length || _repeatCounter>=_repeatSequence) && !context.EndOfContextReached(); }
protected override object[] ReadObjectsFromSubContext(Configuration configuration, BinaryContext context, List<object> objects) { //TODO: how to determine which types must be read from subcontext? throw new NotImplementedException(); }
public FlowTypeReaderFactory(Configuration configuration, BinaryContext context) { ComplexReader = new FlowComplexTypeReader(GetMarkerSize(configuration, context)); }
protected override bool EndReading(Configuration configuration, BinaryContext context, List<object> objects) { return _numberOfObjects < 0 ? context.EndOfContextReached() : objects.Count >= _numberOfObjects || context.EndOfContextReached(); }
protected abstract string DetermineNextTypeName(Configuration configuration, BinaryContext context);
protected abstract Boolean EndReading(Configuration configuration, BinaryContext context, List<Object> objects);
private void CreateTypeReaderFactory(Configuration configuration, BinaryContext context) { if(ReaderFactory==null) { ReaderFactory = new FlowTypeReaderFactory(configuration, context); } }