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