/// <summary>
/// Serializes a data document instance into a Subarray<byte> delimited chunk of thread-local buffer.
/// Because sub-arrays are used for thread-local optimizations, this method should be used in a synchronous-only
/// thread-bound flows, such as serializing payload into Pile and the returned object must be consumed right away as subsequent calls
/// to this method will overwrite the previous content as the same thread local physical buffer is re-used.
/// </summary>
public static Subarray <byte> SerializeToSubarray(TypedDoc doc)
{
var stream = ts_WriteStream;
var writer = ts_Writer;
var result = ts_Subarray;
if (stream == null)
{
stream = new MemoryStream(INITIAL_BUFFER_CAPACITY);
writer = SlimFormat.Instance.GetWritingStreamer();
writer.BindStream(stream);
result = new Subarray <byte>();
ts_WriteStream = stream;
ts_Writer = writer;
ts_Subarray = result;
}
stream.Position = 0;
Serialize(doc, writer, true);
result.Set(stream.GetBuffer(), (int)stream.Position);
//don't let large hunk dangling in the TLS
if (stream.Capacity > BUFFER_TRIM_CAPACITY)
{
stream.SetLength(0);
stream.Capacity = INITIAL_BUFFER_CAPACITY;
}
return(result);
}
public static void Serialize(TypedDoc doc, WritingStreamer streamer, bool header = true)
{
ITypeSerializationCore core;
var tRow = doc.GetType();
if (!s_Serializers.TryGetValue(tRow, out core))
{
throw new ArowException(StringConsts.AROW_TYPE_NOT_SUPPORTED_ERROR.Args(tRow.FullName));
}
var ar = doc as IAmorphousData;
if (ar != null)
{
if (ar.AmorphousDataEnabled)
{
ar.BeforeSave(AROW_TARGET);
}
}
//1 Header
if (header)
{
Writer.WriteHeader(streamer);
}
//2 Body
core.Serialize(doc, streamer);
//3 EORow
Writer.WriteEORow(streamer);
}
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 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));
}
}
/// <summary>
/// Conditionally emits a BIX_DISCRIMINATOR field to the json map if the instance type is decorated with Bix attribute.
/// Returns true when discriminator field was added
/// </summary>
public static bool EmitJsonBixDiscriminator(TypedDoc self, IDictionary <string, object> map)
{
if (self == null || map == null)
{
return(false);
}
var t = self.GetType();
var atr = BixAttribute.TryGetGuidTypeAttribute <TypedDoc, BixAttribute>(t);
if (atr == null)
{
return(false);
}
map[BIX_DISCRIMINATOR] = atr.TypeGuid;
return(true);
}
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);
}
/// <summary>
/// Serializes data document
/// </summary>
public static void Serialize(BixWriter writer, TypedDoc root, BixContext ctx = null)
{
if (!writer.IsAssigned)
{
throw new BixException(StringConsts.ARGUMENT_ERROR + "{0}.!Assigned".Args(nameof(BixWriter)));
}
if (ctx == null)
{
ctx = BixContext.ObtainDefault();
}
//1 Header
if (ctx.HasHeader)
{
Writer.WriteHeader(writer, ctx);
}
//2 Payload
Writer.WriteDoc(writer, root, ctx, isRoot: true);
ctx.DisposeDefault();
}
/// <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 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);
}
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);
}
}
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);
}
}
/// <summary> /// Deserializes typed data document from BixReader /// </summary> public abstract void Deserialize(BixReader reader, TypedDoc doc, BixContext ctx);
void ITypeSerializationCore.Serialize(TypedDoc aDoc, WritingStreamer streamer)
{
var doc = (Azos.Log.Message)aDoc;
// 'gdid' = 1684628583
AW.Write(streamer, 1684628583, doc.Gdid);
// 'guid' = 1684632935
AW.Write(streamer, 1684632935, doc.Guid);
// 'rel' = 7103858
AW.Write(streamer, 7103858, doc.RelatedTo);
// 'app' = 7368801
AW.Write(streamer, 7368801, doc.App);
// 'chnl' = 1819175011
AW.Write(streamer, 1819175011, doc.Channel);
// 'tp' = 28788
Writer.Write(streamer, 28788, (int)doc.Type);
// 'src' = 6517363
AW.Write(streamer, 6517363, doc.Source);
// 'utc' = 6517877
AW.Write(streamer, 6517877, doc.UTCTimeStamp);
// 'hst' = 7631720
if (doc.Host != null)
{
AW.Write(streamer, 7631720, doc.Host);
}
else
{
AW.WriteNull(streamer, 7631720);
}
// 'frm' = 7172710
if (doc.From != null)
{
AW.Write(streamer, 7172710, doc.From);
}
else
{
AW.WriteNull(streamer, 7172710);
}
// 'top' = 7368564
if (doc.Topic != null)
{
AW.Write(streamer, 7368564, doc.Topic);
}
else
{
AW.WriteNull(streamer, 7368564);
}
// 'txt' = 7633012
if (doc.Text != null)
{
AW.Write(streamer, 7633012, doc.Text);
}
else
{
AW.WriteNull(streamer, 7633012);
}
// 'par' = 7496048
if (doc.Parameters != null)
{
AW.Write(streamer, 7496048, doc.Parameters);
}
else
{
AW.WriteNull(streamer, 7496048);
}
// 'exc' = 6518885
if (doc.ExceptionData != null)
{
Writer.WriteRow(streamer, 6518885, doc.ExceptionData);
}
else
{
AW.WriteNull(streamer, 6518885);
}
// 'adims' = 495756862561
if (doc.ArchiveDimensions != null)
{
AW.Write(streamer, 495756862561, doc.ArchiveDimensions);
}
else
{
AW.WriteNull(streamer, 495756862561);
}
}
public static void WriteRow(WritingStreamer streamer, ulong name, TypedDoc doc)
{
streamer.Write(name);
streamer.Write((byte)DataType.Doc);
ArowSerializer.Serialize(doc, streamer, false);
}
void ITypeSerializationCore.Serialize(TypedDoc aDoc, WritingStreamer streamer)
{
var doc = (Azos.WrappedExceptionData)aDoc;
// 'tpname' = 111520460468340
if (doc.TypeName != null)
{
AW.Write(streamer, 111520460468340, doc.TypeName);
}
else
{
AW.WriteNull(streamer, 111520460468340);
}
// 'msg' = 6779757
if (doc.Message != null)
{
AW.Write(streamer, 6779757, doc.Message);
}
else
{
AW.WriteNull(streamer, 6779757);
}
// 'code' = 1701080931
AW.Write(streamer, 1701080931, doc.Code);
// 'src' = 6517363
if (doc.Source != null)
{
AW.Write(streamer, 6517363, doc.Source);
}
else
{
AW.WriteNull(streamer, 6517363);
}
// 'strace' = 111477511058547
if (doc.StackTrace != null)
{
AW.Write(streamer, 111477511058547, doc.StackTrace);
}
else
{
AW.WriteNull(streamer, 111477511058547);
}
// 'appname' = 28549237879894113
if (doc.AppName != null)
{
AW.Write(streamer, 28549237879894113, doc.AppName);
}
else
{
AW.WriteNull(streamer, 28549237879894113);
}
// 'inner' = 491328007785
if (doc.InnerException != null)
{
Writer.WriteRow(streamer, 491328007785, doc.InnerException);
}
else
{
AW.WriteNull(streamer, 491328007785);
}
}
/// <summary> /// Serializes typed data document into BixWriter /// </summary> public abstract void Serialize(BixWriter writer, TypedDoc doc, BixContext ctx);
