public static bool TryDeserialize(TypedDoc doc, ReadingStreamer streamer, bool header = true)
{
ITypeSerializationCore core;
var tDoc = doc.GetType();
if (!s_Serializers.TryGetValue(tDoc, out core))
{
return(false);
}
//1 Header
if (header)
{
Reader.ReadHeader(streamer);
}
//2 Body
core.Deserialize(doc, streamer);
var ar = doc as IAmorphousData;
if (ar != null)
{
if (ar.AmorphousDataEnabled)
{
ar.AfterLoad(AROW_TARGET);
}
}
return(true);
}
public static object ConsumeUnmatched(TypedRow row, ReadingStreamer streamer, string name, DataType dt, DataType?atp)
{
object value = null;
if (atp.HasValue)
{
var len = ReadArrayLength(streamer);
var arr = new object[len];
for (var i = 0; i < arr.Length; i++)
{
arr[i] = readOneAsObject(streamer, dt);
}
value = arr;
}
else
{
value = readOneAsObject(streamer, dt);
}
var arow = row as IAmorphousData;
if (arow == null)
{
return(value);
}
if (!arow.AmorphousDataEnabled)
{
return(value);
}
arow.AmorphousData[name] = value;
return(value);
}
private static object readOneAsObject(ReadingStreamer streamer, DataType dt)
{
switch (dt)
{
case DataType.Null: return(null);
case DataType.Doc: return(readRowAsMap(streamer));
case DataType.Boolean: return(ReadBoolean(streamer));
case DataType.Char: return(ReadChar(streamer));
case DataType.String: return(ReadString(streamer));
case DataType.Single: return(ReadSingle(streamer));
case DataType.Double: return(ReadDouble(streamer));
case DataType.Decimal: return(ReadDecimal(streamer));
case DataType.Amount: return(ReadAmount(streamer));
case DataType.Byte: return(ReadByte(streamer));
case DataType.ByteArray: return(streamer.ReadByteArray());
case DataType.SByte: return(ReadSByte(streamer));
case DataType.Int16: return(ReadInt16(streamer));
case DataType.Int32: return(ReadInt32(streamer));
case DataType.Int64: return(ReadInt64(streamer));
case DataType.UInt16: return(ReadUInt16(streamer));
case DataType.UInt32: return(ReadUInt32(streamer));
case DataType.UInt64: return(ReadUInt64(streamer));
case DataType.DateTime: return(ReadDateTime(streamer));
case DataType.TimeSpan: return(ReadTimeSpan(streamer));
case DataType.Guid: return(ReadGuid(streamer));
case DataType.GDID: return(ReadGDID(streamer));
case DataType.FID: return(ReadFID(streamer));
case DataType.PilePointer: return(ReadPilePointer(streamer));
case DataType.NLSMap: return(ReadNLSMap(streamer));
case DataType.Atom: return(ReadAtom(streamer));
default: throw new ArowException(StringConsts.AROW_DESER_CORRUPT_ERROR);
}
}
public static void Deserialize(TypedDoc doc, ReadingStreamer streamer, bool header = true)
{
var ok = TryDeserialize(doc, streamer, header);
if (!ok)
{
throw new ArowException(StringConsts.AROW_TYPE_NOT_SUPPORTED_ERROR.Args(doc.GetType().FullName));
}
}
public static void ReadHeader(ReadingStreamer streamer)
{
if (streamer.ReadByte() == 0xC0 && streamer.ReadByte() == 0xFE)
{
return;
}
throw new ArowException(StringConsts.AROW_HEADER_CORRUPT_ERROR);
}
public static int ReadArrayLength(ReadingStreamer streamer)
{
var len = streamer.ReadInt();
if (len > Writer.MAX_ARRAY_LENGTH)
{
throw new ArowException(StringConsts.AROW_MAX_ARRAY_LEN_ERROR.Args(len));
}
return(len);
}
public static byte[] ReadByteArray(ReadingStreamer streamer)
{
var len = ReadArrayLength(streamer);
var arr = new byte[len];
for (var i = 0; i < len; i++)
{
arr[i] = streamer.ReadByte();
}
return(arr);
}
public static object ConsumeUnmatched(TypedDoc doc, ReadingStreamer streamer, string name, DataType dt, DataType?atp)
{
object value = null;
if (dt != DataType.Null)
{
if (dt == DataType.Array && !atp.HasValue)
{
atp = Reader.ReadDataType(streamer);
}
if (atp.HasValue)
{
var len = ReadArrayLength(streamer);
var arr = new object[len];
for (var i = 0; i < arr.Length; i++)
{
if (atp.Value == DataType.Doc)
{
var has = streamer.ReadBool();
if (!has)
{
continue;
}
}
arr[i] = readOneAsObject(streamer, atp.Value);
}
value = arr;
}
else
{
value = readOneAsObject(streamer, dt);
}
}
var arow = doc as IAmorphousData;
if (arow == null)
{
return(value);
}
if (!arow.AmorphousDataEnabled)
{
return(value);
}
arow.AmorphousData[name] = value;
return(value);
}
public static TDoc[] ReadRowArray <TDoc>(TypedDoc docScope, ReadingStreamer streamer, string name) where TDoc : TypedDoc, new()
{
var len = Reader.ReadArrayLength(streamer);
var arr = new TDoc[len];
for (var i = 0; i < len; i++)
{
var has = streamer.ReadBool();
if (!has)
{
continue;
}
var vrow = new TDoc();
if (Reader.TryReadRow(docScope, vrow, streamer, name + '_' + i.ToString()))
{
arr[i] = vrow;
}
}
return(arr);
}
public static List <TDoc> ReadRowList <TDoc>(TypedDoc docScope, ReadingStreamer streamer, string name) where TDoc : TypedDoc, new()
{
var len = Reader.ReadArrayLength(streamer);
var lst = new List <TDoc>(len);
for (var i = 0; i < len; i++)
{
var has = streamer.ReadBool();
if (!has)
{
lst.Add(null);
continue;
}
var vrow = new TDoc();
if (Reader.TryReadRow(docScope, vrow, streamer, name + '_' + i.ToString()))
{
lst.Add(vrow);
}
}
return(lst);
}
public static bool TryDeserialize(TypedRow row, ReadingStreamer streamer, bool header = true)
{
ITypeSerializationCore core;
var tRow = row.GetType();
if (!s_Serializers.TryGetValue(tRow, out core))
{
return(false);
}
//1 Header
if (header)
{
Reader.ReadHeader(streamer);
}
//2 Body
core.Deserialize(row, streamer);
return(true);
}
private static JSON.JsonDataMap readRowAsMap(ReadingStreamer streamer)
{
var result = new JSON.JsonDataMap();
while (true)
{
var name = ReadName(streamer);
if (name == 0)
{
return(result);
}
var dt = ReadDataType(streamer);
DataType?atp = null;
if (dt == DataType.Array)
{
atp = ReadDataType(streamer);
}
var val = ConsumeUnmatched(null, streamer, null, dt, atp);
result[CodeGenerator.GetName(name)] = val;
}
}
public static bool TryReadRow(TypedDoc docScope, TypedDoc newDoc, ReadingStreamer streamer, string name)
{
var ok = ArowSerializer.TryDeserialize(newDoc, streamer, false);
if (ok)
{
return(true);
}
var map = readRowAsMap(streamer);//unconditionally to advance stream
var arow = docScope as IAmorphousData;
if (arow == null)
{
return(false);
}
if (!arow.AmorphousDataEnabled)
{
return(false);
}
arow.AmorphousData[name] = map;
return(false);
}
/// <summary>
/// Deserializes data document from the specified byte[] using thread-local caching optimizations
/// </summary>
public static void Deserialize(TypedDoc doc, byte[] data, int offset)
{
var stream = ts_ReadStream;
var reader = ts_Reader;
if (stream == null)
{
stream = new BufferSegmentReadingStream();
reader = SlimFormat.Instance.GetReadingStreamer();
reader.BindStream(stream);
ts_ReadStream = stream;
ts_Reader = reader;
}
stream.BindBuffer(data, offset, data.Length - offset);
try
{
Deserialize(doc, reader, true);
}
finally
{
stream.UnsafeBindBuffer(null, 0, 0);
}
}
public static Atom ReadAtom(ReadingStreamer streamer)
{
return(streamer.ReadAtom());
}
public static JSON.NLSMap ReadNLSMap(ReadingStreamer streamer)
{
return(streamer.ReadNLSMap());
}
public static Pile.PilePointer ReadPilePointer(ReadingStreamer streamer)
{
return(streamer.ReadPilePointer());
}
public static FID ReadFID(ReadingStreamer streamer)
{
return(streamer.ReadFID());
}
public static Decimal ReadDecimal(ReadingStreamer streamer)
{
return(streamer.ReadDecimal());
}
public static UInt32 ReadUInt32(ReadingStreamer streamer)
{
return(streamer.ReadUInt());
}
public static UInt16 ReadUInt16(ReadingStreamer streamer)
{
return(streamer.ReadUShort());
}
public static SByte ReadSByte(ReadingStreamer streamer)
{
return(streamer.ReadSByte());
}
public static Financial.Amount ReadAmount(ReadingStreamer streamer)
{
return(streamer.ReadAmount());
}
void ITypeSerializationCore.Deserialize(TypedDoc aDoc, ReadingStreamer streamer)
{
var doc = (Azos.Log.Message)aDoc;
while (true)
{
var name = Reader.ReadName(streamer);
if (name == 0)
{
break; //EODoc
}
var dt = Reader.ReadDataType(streamer);
DataType?atp = null;
switch (name)
{
case 1684628583:
{ // 'gdid'
if (dt == DataType.GDID)
{
doc.Gdid = Reader.ReadGDID(streamer);
}
else
{
break;
}
continue;
}
case 1684632935:
{ // 'guid'
if (dt == DataType.Guid)
{
doc.Guid = Reader.ReadGuid(streamer);
}
else
{
break;
}
continue;
}
case 7103858:
{ // 'rel'
if (dt == DataType.Guid)
{
doc.RelatedTo = Reader.ReadGuid(streamer);
}
else
{
break;
}
continue;
}
case 7368801:
{ // 'app'
if (dt == DataType.Atom)
{
doc.App = Reader.ReadAtom(streamer);
}
else
{
break;
}
continue;
}
case 1819175011:
{ // 'chnl'
if (dt == DataType.Atom)
{
doc.Channel = Reader.ReadAtom(streamer);
}
else
{
break;
}
continue;
}
case 28788:
{ // 'tp'
if (dt != DataType.Int32)
{
break;
}
var ev = (@Azos.@Log.@MessageType)Reader.ReadInt32(streamer);
doc.Type = ev;
continue;
}
case 6517363:
{ // 'src'
if (dt == DataType.Int32)
{
doc.Source = Reader.ReadInt32(streamer);
}
else
{
break;
}
continue;
}
case 6517877:
{ // 'utc'
if (dt == DataType.DateTime)
{
doc.UTCTimeStamp = Reader.ReadDateTime(streamer);
}
else
{
break;
}
continue;
}
case 7631720:
{ // 'hst'
if (dt == DataType.Null)
{
doc.Host = null;
}
else if (dt == DataType.String)
{
doc.Host = Reader.ReadString(streamer);
}
else
{
break;
}
continue;
}
case 7172710:
{ // 'frm'
if (dt == DataType.Null)
{
doc.From = null;
}
else if (dt == DataType.String)
{
doc.From = Reader.ReadString(streamer);
}
else
{
break;
}
continue;
}
case 7368564:
{ // 'top'
if (dt == DataType.Null)
{
doc.Topic = null;
}
else if (dt == DataType.String)
{
doc.Topic = Reader.ReadString(streamer);
}
else
{
break;
}
continue;
}
case 7633012:
{ // 'txt'
if (dt == DataType.Null)
{
doc.Text = null;
}
else if (dt == DataType.String)
{
doc.Text = Reader.ReadString(streamer);
}
else
{
break;
}
continue;
}
case 7496048:
{ // 'par'
if (dt == DataType.Null)
{
doc.Parameters = null;
}
else if (dt == DataType.String)
{
doc.Parameters = Reader.ReadString(streamer);
}
else
{
break;
}
continue;
}
case 6518885:
{ // 'exc'
if (dt == DataType.Null)
{
doc.ExceptionData = null; continue;
}
if (dt != DataType.Doc)
{
break;
}
var vdoc = new Azos.WrappedExceptionData();
if (Reader.TryReadRow(doc, vdoc, streamer, CodeGenerator.GetName(name)))
{
doc.ExceptionData = vdoc;
}
continue;
}
case 495756862561:
{ // 'adims'
if (dt == DataType.Null)
{
doc.ArchiveDimensions = null;
}
else if (dt == DataType.String)
{
doc.ArchiveDimensions = Reader.ReadString(streamer);
}
else
{
break;
}
continue;
}
}
Reader.ConsumeUnmatched(doc, streamer, CodeGenerator.GetName(name), dt, atp);
}
}
void ITypeSerializationCore.Deserialize(TypedDoc aDoc, ReadingStreamer streamer)
{
var doc = (Azos.WrappedExceptionData)aDoc;
while (true)
{
var name = Reader.ReadName(streamer);
if (name == 0)
{
break; //EODoc
}
var dt = Reader.ReadDataType(streamer);
DataType?atp = null;
switch (name)
{
case 111520460468340:
{ // 'tpname'
if (dt == DataType.Null)
{
doc.TypeName = null;
}
else if (dt == DataType.String)
{
doc.TypeName = Reader.ReadString(streamer);
}
else
{
break;
}
continue;
}
case 6779757:
{ // 'msg'
if (dt == DataType.Null)
{
doc.Message = null;
}
else if (dt == DataType.String)
{
doc.Message = Reader.ReadString(streamer);
}
else
{
break;
}
continue;
}
case 1701080931:
{ // 'code'
if (dt == DataType.Int32)
{
doc.Code = Reader.ReadInt32(streamer);
}
else
{
break;
}
continue;
}
case 6517363:
{ // 'src'
if (dt == DataType.Null)
{
doc.Source = null;
}
else if (dt == DataType.String)
{
doc.Source = Reader.ReadString(streamer);
}
else
{
break;
}
continue;
}
case 111477511058547:
{ // 'strace'
if (dt == DataType.Null)
{
doc.StackTrace = null;
}
else if (dt == DataType.String)
{
doc.StackTrace = Reader.ReadString(streamer);
}
else
{
break;
}
continue;
}
case 491328007785:
{ // 'inner'
if (dt == DataType.Null)
{
doc.InnerException = null; continue;
}
if (dt != DataType.Doc)
{
break;
}
var vdoc = new Azos.WrappedExceptionData();
if (Reader.TryReadRow(doc, vdoc, streamer, CodeGenerator.GetName(name)))
{
doc.InnerException = vdoc;
}
continue;
}
}
Reader.ConsumeUnmatched(doc, streamer, CodeGenerator.GetName(name), dt, atp);
}
}
public static TimeSpan ReadTimeSpan(ReadingStreamer streamer)
{
return(streamer.ReadTimeSpan());
}
public static Guid ReadGuid(ReadingStreamer streamer)
{
return(streamer.ReadGuid());
}
public static Double ReadDouble(ReadingStreamer streamer)
{
return(streamer.ReadDouble());
}
public static UInt64 ReadUInt64(ReadingStreamer streamer)
{
return(streamer.ReadULong());
}
public static DateTime ReadDateTime(ReadingStreamer streamer)
{
return(streamer.ReadDateTime());
}