private static void ReadMemberValues(DeserializationState state, ClassRecord record)
{
foreach (var member in record.Members)
{
var val = ReadMemberValue(state, member);
member.Value = val;
}
}
private static void ReadArrayLengths(DeserializationState state, ArrayRecord record)
{
record.Lengths.Capacity = record.Rank;
for (var i = 0; i < record.Rank; ++i)
{
record.Lengths.Add(state.array.ReadInt32LEFromBytes(ref state.idx));
}
}
private static void ReadArrayValues(DeserializationState state, ArrayRecord record)
{
var maxLen = record.Lengths.Aggregate(1, (cur, length) => cur * length);
record.ValuesAsVector.Capacity = maxLen;
for (var i = 0; i < maxLen; ++i)
{
record.ValuesAsVector.Add(ReadMemberValue(state, record));
}
}
private static void EnsureWasParsed(DeserializationState stateFn)
{
if (
!(stateFn.Target.GetType() == typeof(OptionalValueDeSerializer) ||
stateFn.Target.GetType() == typeof(MediaOptioalValueDeserializer))
)
{
throw new DeserializationException("Invalid EOF required fields where not deserialized");
}
}
private static void ReadMembers(DeserializationState state, ClassRecord record)
{
record.TypeName = state.array.Read7BitLengthPrefixedString(ref state.idx);
var cap = state.array.ReadInt32LEFromBytes(ref state.idx);
record.Members.Capacity = cap;
for (var i = 0; i < cap; ++i)
{
var member = new ClassRecordMember();
member.Name = state.array.Read7BitLengthPrefixedString(ref state.idx);
record.Members.Add(member);
}
}
private static void ReadMemberTypes(DeserializationState state, ClassRecord record)
{
// First normal info
foreach (var member in record.Members)
{
ReadBasicTypeInfo(state, member);
}
// Then additional info, if any
foreach (var member in record.Members)
{
ReadAdditionalTypeInfo(state, member);
}
}
public static async Task <SDP> ReadSDP(PipeReader reader)
{
var session = new DeserializationSession();
DeserializationState stateFn = Serializer.Instance.ReadValue;
while (true)
{
ReadResult result = await reader.ReadAsync();
ReadOnlySequence <byte> buffer = result.Buffer;
SequencePosition? position = null;
do
{
// Look for a EOL in the buffer
position = buffer.PositionOf(ByteLF);
if (position != null)
{
stateFn = stateFn(TrimSDPLineCR(buffer.Slice(0, position.Value)), session);
buffer = buffer.Slice(buffer.GetPosition(1, position.Value));
}
}while (position != null);
reader.AdvanceTo(buffer.Start, buffer.End);
if (result.IsCompleted)
{
if (!buffer.IsEmpty)
{
stateFn = stateFn(buffer.Slice(buffer.Start, buffer.End).ToSpan(), session);
}
break;
}
}
EnsureWasParsed(stateFn);
// Mark the PipeReader as complete
reader.Complete();
return(session.ParsedValue);
}
private static Boolean CheckPlaceholder(DeserializationState state, Object value, out AbstractRecord rec)
{
var record = value as AbstractRecord;
var retVal = record != null;
if (retVal)
{
var ph = record as RecordPlaceholder;
retVal = ph != null;
rec = retVal ? state.records[((RecordPlaceholder)record).id] : null;
if (!retVal)
{
switch (record.Kind)
{
case RecordKind.Class:
var claas = (ClassRecord)record;
foreach (var member in claas.Members)
{
if (CheckPlaceholder(state, member.Value, out rec))
{
member.Value = rec;
}
}
break;
case RecordKind.Array:
var array = (ArrayRecord)record;
for (var i = 0; i < array.ValuesAsVector.Count; ++i)
{
if (CheckPlaceholder(state, array.ValuesAsVector[i], out rec))
{
array.ValuesAsVector[i] = rec;
}
}
break;
}
}
((ClassRecord)rec).IsSerializedInPlace = !retVal;
}
else
{
rec = null;
}
return(retVal);
}
private static void ReadAdditionalTypeInfo(DeserializationState state, ElementWithTypeInfo member)
{
switch (state.typeInfos[member])
{
case BinaryTypeEnumeration.Primitive:
case BinaryTypeEnumeration.PrimitiveArray:
state.primitiveTypeInfos.Add(member, (PrimitiveTypeEnumeration)state.array.ReadByteFromBytes(ref state.idx));
break;
case BinaryTypeEnumeration.SystemClass:
member.TypeName = state.array.Read7BitLengthPrefixedString(ref state.idx);
break;
case BinaryTypeEnumeration.Class:
member.TypeName = state.array.Read7BitLengthPrefixedString(ref state.idx);
member.AssemblyName = state.assemblies[state.array.ReadInt32LEFromBytes(ref state.idx)];
break;
}
}
private static Object ReadMemberValue(DeserializationState state, Object member)
{
BinaryTypeEnumeration typeInfo;
if (state.typeInfos.TryGetValue(member, out typeInfo))
{
switch (typeInfo)
{
case BinaryTypeEnumeration.Primitive:
return(ReadPrimitiveValue(state, state.primitiveTypeInfos[member]));
default:
return(ReadSingleRecord(state));
}
}
else
{
throw new NotImplementedException("Neither SystemClassWithMember nor ClassWithMembers is currently implemented.");
}
}
public static SDP ReadSDP(ReadOnlySpan <byte> data)
{
var session = new DeserializationSession();
DeserializationState stateFn = Serializer.Instance.ReadValue;
var remainingSlice = data;
int position = -1;
while ((position = remainingSlice.IndexOf(ByteLF)) != -1)
{
stateFn = stateFn(TrimSDPLineCR(remainingSlice.Slice(0, position)), session);
remainingSlice = remainingSlice.Slice(position + 1);
}
if (remainingSlice.Length > 0)
{
stateFn = stateFn(remainingSlice, session);
}
EnsureWasParsed(stateFn);
return(session.ParsedValue);
}
public void CanDeSerialize()
{
var field = $"o=jdoe 2890844526 2890842807 IN IP4 10.47.16.5".ToByteArray();
var session = new DeserializationSession()
{
ParsedValue = new SDP()
};
var stateFn = OriginSerializer.Instance.ReadValue(field, session);
var value = new Origin()
{
UserName = "******",
SessionId = 2890844526,
SessionVersion = 2890842807,
Nettype = "IN",
AddrType = "IP4",
UnicastAddress = "10.47.16.5"
};
DeserializationState nextStateFn = SessionNameSerializer.Instance.ReadValue;
Assert.Equal(stateFn, nextStateFn);
Assert.True(CheckIfOriginSareSame(session.ParsedValue.Origin, value));
}
public static IList <AbstractRecord> ReadNRBFRecords(Byte[] array, ref Int32 idx, Int32 maxIndex)
{
var state = new DeserializationState(array, idx);
var list = new List <AbstractRecord>();
while (idx < maxIndex && !state.recordsEnded)
{
var record = ReadSingleRecord(state);
if (record != null)
{
list.Add(record);
}
}
for (var i = 0; i < list.Count; ++i)
{
var rec = list[i];
AbstractRecord actual;
if (CheckPlaceholder(state, rec, out actual))
{
list[i] = actual;
}
}
return(list);
}
private static void ReadArrayInformation(DeserializationState state, ArrayRecord record)
{
var arType = (BinaryArrayTypeEnumeration)state.array.ReadByteFromBytes(ref state.idx);
record.ArrayKind = arType;
record.Rank = state.array.ReadInt32LEFromBytes(ref state.idx);
ReadArrayLengths(state, record);
switch (arType)
{
case BinaryArrayTypeEnumeration.SingleOffset:
case BinaryArrayTypeEnumeration.JaggedOffset:
case BinaryArrayTypeEnumeration.RectangularOffset:
record.LowerBounds.Capacity = record.Rank;
for (var i = 0; i < record.Rank; ++i)
{
record.LowerBounds.Add(state.array.ReadInt32LEFromBytes(ref state.idx));
}
break;
}
ReadBasicTypeInfo(state, record);
ReadAdditionalTypeInfo(state, record);
}
internal SocketBufferStream(SocketBufferManager bufferManager)
{
_bufferManager = bufferManager;
_buffers = new List <SocketBuffer>();
_state = DeserializationState.DeserializingLength;
}
private static void ReadBasicTypeInfo(DeserializationState state, Object member)
{
state.typeInfos.Add(member, (BinaryTypeEnumeration)state.array.ReadByteFromBytes(ref state.idx));
}
public bool ReadCommand(out object command)
{
command = null;
// Start or end set karna hai buffer ka for command...
switch (_state)
{
case DeserializationState.DeserializingLength:
if (!ReadCommandLenght(out _commandLength))
{
return(false);
}
_state = DeserializationState.DeserailizingCommad;
_buffers.Clear();
if (!GetDataBuffers(_commandLength, _buffers))
{
return(false);
}
_position = _currBufferIndex = 0;
_commandStart = _commandEnd = 0;
if (_buffers.Count > 0)
{
_commandStart = (int)_buffers[0].ReadIndex;
int commandLength = _commandLength;
for (int i = 0; i < _buffers.Count; i++)
{
if (_buffers[i].UnreadBytes > commandLength)
{
_commandEnd = (int)_buffers[i].ReadIndex + commandLength;
}
else
{
commandLength -= (int)_buffers[i].UnreadBytes;
}
}
}
command = ProtoBuf.Serializer.Deserialize <Common.Protobuf.Command>(this);
_state = DeserializationState.DeserializingLength;
return(true);
case DeserializationState.DeserailizingCommad:
_buffers.Clear();
if (!GetDataBuffers(_commandLength, _buffers))
{
return(false);
}
_position = _currBufferIndex = 0;
_commandStart = _commandEnd = 0;
if (_buffers.Count > 0)
{
_commandStart = (int)_buffers[0].ReadIndex;
int commandLength = _commandLength;
for (int i = 0; i < _buffers.Count; i++)
{
if (_buffers[i].UnreadBytes > commandLength)
{
_commandEnd = (int)_buffers[i].ReadIndex + commandLength;
}
else
{
commandLength -= (int)_buffers[i].UnreadBytes;
}
}
}
command = ProtoBuf.Serializer.Deserialize <Common.Protobuf.Command>(this);
_state = DeserializationState.DeserializingLength;
return(true);
}
return(false);
}
private static Object ReadPrimitiveValue(DeserializationState state, PrimitiveTypeEnumeration primitive)
{
Object value;
switch (primitive)
{
case PrimitiveTypeEnumeration.Boolean:
value = state.array.ReadByteFromBytes(ref state.idx) != 0;
break;
case PrimitiveTypeEnumeration.Byte:
value = state.array.ReadByteFromBytes(ref state.idx);
break;
case PrimitiveTypeEnumeration.Char:
var startIdx = state.idx;
var charArray = new Char[1];
Int32 charsRead;
do
{
++state.idx;
charsRead = UTF8.GetChars(state.array, startIdx, state.idx - startIdx, charArray, 0);
} while (charsRead == 0);
value = charArray[0];
break;
case PrimitiveTypeEnumeration.Decimal:
var str = state.array.Read7BitLengthPrefixedString(ref state.idx);
Decimal d;
Decimal.TryParse(str, out d);
// I'm not quite sure why but apparently actual binary value of decimal follows?
var int1 = state.array.ReadInt32LEFromBytes(ref state.idx);
var int2 = state.array.ReadInt32LEFromBytes(ref state.idx);
var int3 = state.array.ReadInt32LEFromBytes(ref state.idx);
var int4 = state.array.ReadInt32LEFromBytes(ref state.idx);
value = new Decimal(new[] { int1, int2, int3, int4 });
break;
case PrimitiveTypeEnumeration.Double:
value = state.array.ReadDoubleLEFromBytes(ref state.idx);
break;
case PrimitiveTypeEnumeration.Int16:
value = state.array.ReadInt16LEFromBytes(ref state.idx);
break;
case PrimitiveTypeEnumeration.Int32:
value = state.array.ReadInt32LEFromBytes(ref state.idx);
break;
case PrimitiveTypeEnumeration.Int64:
value = state.array.ReadInt64LEFromBytes(ref state.idx);
break;
case PrimitiveTypeEnumeration.SByte:
value = state.array.ReadSByteFromBytes(ref state.idx);
break;
case PrimitiveTypeEnumeration.Single:
value = state.array.ReadSingleLEFromBytes(ref state.idx);
break;
case PrimitiveTypeEnumeration.TimeSpan:
value = TimeSpan.FromTicks(state.array.ReadInt64LEFromBytes(ref state.idx));
break;
case PrimitiveTypeEnumeration.DateTime:
value = DateTime.FromBinary(state.array.ReadInt64LEFromBytes(ref state.idx));
break;
case PrimitiveTypeEnumeration.UInt16:
value = state.array.ReadUInt16LEFromBytes(ref state.idx);
break;
case PrimitiveTypeEnumeration.UInt32:
value = state.array.ReadUInt32LEFromBytes(ref state.idx);
break;
case PrimitiveTypeEnumeration.UInt64:
value = state.array.ReadUInt64LEFromBytes(ref state.idx);
break;
case PrimitiveTypeEnumeration.Null:
value = null;
break;
case PrimitiveTypeEnumeration.String:
value = state.array.Read7BitLengthPrefixedString(ref state.idx);
break;
default:
throw new InvalidOperationException("Unknown primitive type: " + primitive + ".");
}
return(value);
}
private static AbstractRecord ReadSingleRecord(DeserializationState state)
{
AbstractRecord retVal;
if (state.nullCount > 0)
{
--state.nullCount;
retVal = null;
}
else
{
ClassRecord cRecord;
ArrayRecord aRecord;
var recType = (RecordTypeEnumeration)state.array.ReadByteFromBytes(ref state.idx);
switch (recType)
{
case RecordTypeEnumeration.SerializedStreamHeader:
state.array.Skip(ref state.idx, 16); // Skip the header of 4 ints
retVal = null;
break;
case RecordTypeEnumeration.ClassWithID:
cRecord = NewRecord <ClassRecord>(state);
var refID = state.array.ReadInt32LEFromBytes(ref state.idx);
var refRecord = (ClassRecord)state.records[refID];
// Copy metadata from referenced object
cRecord.AssemblyName = refRecord.AssemblyName;
cRecord.TypeName = refRecord.TypeName;
cRecord.Members.Capacity = refRecord.Members.Count;
for (var i = 0; i < refRecord.Members.Count; ++i)
{
var member = new ClassRecordMember();
var refMember = refRecord.Members[i];
member.AssemblyName = refMember.AssemblyName;
member.TypeName = refMember.TypeName;
member.Name = refMember.Name;
cRecord.Members.Add(member);
}
// Read values
ReadMemberValues(state, cRecord);
retVal = cRecord;
break;
case RecordTypeEnumeration.SystemClassWithMembers:
cRecord = NewRecord <ClassRecord>(state);
ReadMembers(state, cRecord);
ReadMemberValues(state, cRecord);
retVal = cRecord;
break;
case RecordTypeEnumeration.ClassWithMembers:
cRecord = NewRecord <ClassRecord>(state);
ReadMembers(state, cRecord);
cRecord.AssemblyName = state.assemblies[state.array.ReadInt32LEFromBytes(ref state.idx)];
ReadMemberValues(state, cRecord);
retVal = cRecord;
break;
case RecordTypeEnumeration.SystemClassWithMembersAndTypes:
cRecord = NewRecord <ClassRecord>(state);
ReadMembers(state, cRecord);
ReadMemberTypes(state, cRecord);
ReadMemberValues(state, cRecord);
retVal = cRecord;
break;
case RecordTypeEnumeration.ClassWithMembersAndTypes:
cRecord = NewRecord <ClassRecord>(state);
ReadMembers(state, cRecord);
ReadMemberTypes(state, cRecord);
cRecord.AssemblyName = state.assemblies[state.array.ReadInt32LEFromBytes(ref state.idx)];
ReadMemberValues(state, cRecord);
retVal = cRecord;
break;
case RecordTypeEnumeration.BinaryObjectString:
var strRecord = NewRecord <StringRecord>(state);
strRecord.StringValue = state.array.Read7BitLengthPrefixedString(ref state.idx);
retVal = strRecord;
break;
case RecordTypeEnumeration.BinaryArray:
aRecord = NewRecord <ArrayRecord>(state);
ReadArrayInformation(state, aRecord);
ReadArrayValues(state, aRecord);
retVal = aRecord;
break;
case RecordTypeEnumeration.MemberPrimitiveTyped:
var pRecord = new PrimitiveWrapperRecord();
pRecord.Value = ReadPrimitiveValue(state, (PrimitiveTypeEnumeration)state.array.ReadByteFromBytes(ref state.idx));
retVal = pRecord;
break;
case RecordTypeEnumeration.MemberReference:
retVal = new RecordPlaceholder(state.array.ReadInt32LEFromBytes(ref state.idx));
break;
case RecordTypeEnumeration.ObjectNull:
retVal = null;
break;
case RecordTypeEnumeration.MessageEnd:
state.recordsEnded = true;
retVal = null;
break;
case RecordTypeEnumeration.BinaryLibrary:
// VS2012 should guarantee that first parameter will be executed first
state.assemblies.Add(state.array.ReadInt32LEFromBytes(ref state.idx), state.array.Read7BitLengthPrefixedString(ref state.idx));
retVal = null;
break;
case RecordTypeEnumeration.ObjectNullMultiple256:
state.nullCount = state.array.ReadByteFromBytes(ref state.idx) - 1; // Returning the first null
retVal = null;
break;
case RecordTypeEnumeration.ObjectNullMultiple:
state.nullCount = state.array.ReadInt32LEFromBytes(ref state.idx) - 1; // Returning the first null
retVal = null;
break;
case RecordTypeEnumeration.ArraySinglePrimitive:
aRecord = NewRecord <ArrayRecord>(state);
state.typeInfos.Add(aRecord, BinaryTypeEnumeration.Primitive);
ReadArrayLengths(state, aRecord);
ReadAdditionalTypeInfo(state, aRecord);
ReadArrayValues(state, aRecord);
retVal = aRecord;
break;
case RecordTypeEnumeration.ArraySingleObject:
aRecord = NewRecord <ArrayRecord>(state);
state.typeInfos.Add(aRecord, BinaryTypeEnumeration.Object);
ReadArrayLengths(state, aRecord);
ReadArrayValues(state, aRecord);
retVal = aRecord;
break;
case RecordTypeEnumeration.ArraySingleString:
aRecord = NewRecord <ArrayRecord>(state);
state.typeInfos.Add(aRecord, BinaryTypeEnumeration.String);
ReadArrayLengths(state, aRecord);
ReadArrayValues(state, aRecord);
retVal = aRecord;
break;
case RecordTypeEnumeration.MethodCall:
throw new NotImplementedException(); // TODO
case RecordTypeEnumeration.MethodReturn:
throw new NotImplementedException(); // TODO
default:
throw new InvalidOperationException("Unsupported record type: " + recType + ".");
}
}
return(retVal);
}
