public override void WriteData(FastBinaryWriter writer, Object additionalInfo)
{
base.WriteData(writer, additionalInfo);
writer.Write(Expanded);
writer.WriteSafeString(Caption);
// write children
writer.Write(Children.Count);
foreach (RICustomDataElement element in Children)
{
Int32 elementTypeHash = RICustomDataFieldTypeHash;
if (element.CustomDataType == RICustomDataElementType.Row)
{
elementTypeHash = RICustomDataRowTypeHash;
}
else if (element.CustomDataType == RICustomDataElementType.Category)
{
elementTypeHash = RICustomDataCategoryTypeHash;
}
else if (element.CustomDataType == RICustomDataElementType.Container)
{
elementTypeHash = RICustomDataContainerTypeHash;
}
writer.Write(elementTypeHash);
writer.Write(element);
}
}
static void Write <R>(R reader, OutputStream output, string toProtocol)
{
if (toProtocol == "compact")
{
var writer = new CompactBinaryWriter <OutputStream>(output);
Serialize.To(writer, Deserialize <Compat> .From(reader));
}
else if (toProtocol == "fast")
{
var writer = new FastBinaryWriter <OutputStream>(output);
Serialize.To(writer, Deserialize <Compat> .From(reader));
}
else if (toProtocol == "simple")
{
var writer = new SimpleBinaryWriter <OutputStream>(output);
Serialize.To(writer, Deserialize <Compat> .From(reader));
}
else if (toProtocol == "simple2")
{
var writer = new SimpleBinaryWriter <OutputStream>(output, 2);
Serialize.To(writer, Deserialize <Compat> .From(reader));
}
else
{
Console.WriteLine("Unsupported output protocol {0}", toProtocol);
}
output.Flush();
}
public virtual void WriteData(FastBinaryWriter writer, Object additionalInfo)
{
writer.Write(SaveOnNewDay);
writer.Write(SaveOnMsgLimit);
writer.Write(RecycleFilesEvery);
writer.Write(SaveOnSize);
}
public void Setup()
{
googleProtobufPersonBytes = BenchmarksData.ProtobufPerson().ToByteArray();
var protobufNetStream = new MemoryStream();
ProtoBuf.Serializer.Serialize(protobufNetStream, BenchmarksData.ProtobufNetPerson());
protobufNetPersonBytes = protobufNetStream.ToArray();
var bondPerson = BenchmarksData.BondPerson();
var compactOutput = new OutputBuffer(256);
var compactWriter = new CompactBinaryWriter <OutputBuffer>(compactOutput);
var compactBondSerializer = new Serializer <CompactBinaryWriter <OutputBuffer> >(typeof(Bond.Person));
compactBondSerializer.Serialize(bondPerson, compactWriter);
compactBondPersonBytes = compactOutput.Data.ToArray();
var fastOutput = new OutputBuffer(256);
var fastWriter = new FastBinaryWriter <OutputBuffer>(fastOutput);
var fastBondSerializer = new Serializer <FastBinaryWriter <OutputBuffer> >(typeof(Bond.Person));
fastBondSerializer.Serialize(bondPerson, fastWriter);
fastBondPersonBytes = fastOutput.Data.ToArray();
}
public static void SetupBondBinary(
out Action <object, ChunkedMemoryStream> serialize,
out Func <ChunkedMemoryStream, Type, object> deserialize)
{
var serializers = new Dictionary <Type, Bond.Serializer <FastBinaryWriter <OutputStream> > >();
var deserializers = new Dictionary <Type, Bond.Deserializer <FastBinaryReader <InputStream> > >();
serialize = (obj, stream) =>
{
var output = new OutputStream(stream, 512);
var writer = new FastBinaryWriter <OutputStream>(output);
Bond.Serializer <FastBinaryWriter <OutputStream> > serializer;
var type = obj.GetType();
if (!serializers.TryGetValue(type, out serializer))
{
serializers[type] = serializer = new Bond.Serializer <FastBinaryWriter <OutputStream> >(type);
}
serializer.Serialize(obj, writer);
output.Flush();
};
deserialize = (stream, type) =>
{
var input = new InputStream(stream, 512);
var reader = new FastBinaryReader <InputStream>(input);
Bond.Deserializer <FastBinaryReader <InputStream> > deserializer;
if (!deserializers.TryGetValue(type, out deserializer))
{
deserializers[type] = deserializer = new Bond.Deserializer <FastBinaryReader <InputStream> >(type);
}
return(deserializer.Deserialize(reader));
};
}
public override void Serialize(object serializable, Stream outputStream)
{
Initialize();
var output = new OutputStream(outputStream);
var writer = new FastBinaryWriter<OutputStream>(output);
_serializerStream.Serialize(serializable, writer);
}
public void Store(FastBinaryWriter writer)
{
writer.WriteByte((byte)TraceEntryTypes.HeapAllocation);
writer.WriteInt32(Id);
writer.WriteUInt32(Size);
writer.WriteUInt64(Address);
}
public virtual void WriteData(FastBinaryWriter writer, Object additionalInfo)
{
writer.Write(SessionId);
writer.Write(RequestId);
writer.Write(Sequence);
writer.WriteByteArray(Chunk);
}
public override void WriteData(FastBinaryWriter writer, Object additionalInfo)
{
base.WriteData(writer, additionalInfo);
// Hint is no longer used. This line is left here for backward compatibility
writer.WriteSafeString(null);
writer.Write(ColumnPos);
if (writer.WriteNullState(Value))
{
switch (Column.FieldTypeId)
{
case RICustomDataFieldIdType.Decimal: writer.Write(Decimal.Parse(Value.ToString())); break;
case RICustomDataFieldIdType.Integer: writer.Write(Int64.Parse(Value.ToString())); break;
case RICustomDataFieldIdType.DateTime: writer.Write((DateTime)Value); break;
case RICustomDataFieldIdType.Boolean: writer.Write((Boolean)Value); break;
case RICustomDataFieldIdType.String: writer.Write(Value.ToString()); break;
case RICustomDataFieldIdType.Object: writer.Write(Value.ToString()); break;
case RICustomDataFieldIdType.Unknown: writer.Write(Value.ToString()); break;
}
}
}
public virtual void WriteData(FastBinaryWriter writer, Object additionalInfo)
{
writer.Write(FColor);
writer.Write(FHue);
writer.Write(FSaturation);
writer.Write(FBrightness);
}
public virtual void WriteData(FastBinaryWriter writer, Object additionalInfo)
{
// Version 5.0 data types
writer.Write(FSequenceID);
writer.Write(FSessionID);
writer.Write(FRequestID);
writer.Write(FSourceUtcOffset);
writer.Write(FDateTime);
writer.Write(FDomainID);
writer.Write(FProcessID);
writer.Write(FThreadID);
writer.Write(FCategory);
writer.Write(FApplication);
writer.Write(FMachineName);
writer.Write(FUserDomainName);
writer.Write(FUserName);
writer.Write(FIndentLevel);
writer.Write(FBkColor.ToArgb());
writer.Write(FMessageType.GetHashCode());
writer.Write(FMessageSubType);
writer.Write(FMessage);
writer.Write(FDetailType);
writer.Write(FExtPropertyContainer);
writer.Write(FSubDetails);
writer.Write(FDetails);
}
public static int FastBondSize <T>(this T data)
{
var output = new OutputBuffer();
var writer = new FastBinaryWriter <OutputBuffer>(output);
Serialize.To(writer, data);
return(output.Data.Count);
}
public static ArraySegment <byte> SerializeFB <T>(T obj)
{
var output = new OutputBuffer();
var writer = new FastBinaryWriter <OutputBuffer>(output);
Serialize.To(writer, obj);
return(output.Data);
}
public override string Serialize(object serializable)
{
Initialize();
var output = new OutputBuffer(2*1024);
var writer = new FastBinaryWriter<OutputBuffer>(output);
_serializer.Serialize(serializable, writer);
return Convert.ToBase64String(output.Data.Array, output.Data.Offset, output.Data.Count);
}
public override void WriteData(FastBinaryWriter writer, Object additionalInfo)
{
base.WriteData(writer, additionalInfo);
writer.Write(FExtraData);
writer.Write(FExtraDataTypeHash);
writer.Write(Fields.ToArray());
}
public virtual void WriteData(FastBinaryWriter writer, Object additionalInfo)
{
writer.Write(FieldTypeId.GetHashCode());
writer.Write(Justification.GetHashCode());
writer.WriteSafeString(Caption);
writer.WriteSafeString(Format);
writer.WriteSafeString(NullText);
}
public override void Serialize(object serializable, Stream outputStream)
{
Initialize();
var output = new OutputStream(outputStream);
var writer = new FastBinaryWriter <OutputStream>(output);
_serializerStream.Serialize(serializable, writer);
}
public static void MarshalFB <T>(T obj, Stream stream)
{
var output = new OutputStream(stream, 11);
var writer = new FastBinaryWriter <OutputStream>(output);
Marshal.To(writer, obj);
output.Flush();
}
public int FastBond()
{
var output = new OutputBuffer(256);
var writer = new FastBinaryWriter <OutputBuffer>(output);
fastBondSerializer.Serialize(BondPerson, writer);
return(output.Data.Count);
}
public static void SerializeFB(IBonded obj, Stream stream)
{
var output = new OutputStream(stream, 11);
var writer = new FastBinaryWriter <OutputStream>(output);
Serialize.To(writer, obj);
output.Flush();
}
private static void WriteBooleanArray(FastBinaryWriter writer, Boolean[] array)
{
writer.Write(array.Length);
foreach (Boolean value in array)
{
writer.Write(value);
}
}
public virtual void WriteData(FastBinaryWriter writer, Object additionalInfo)
{
writer.Write(FFilterInfo);
writer.Write(FFilterDefined);
WriteBooleanArray(writer, FMessages);
WriteBooleanArray(writer, FCheckpoints);
WriteBooleanArray(writer, FCheckmarks);
WriteBooleanArray(writer, FLevels);
}
public void Store(FastBinaryWriter writer)
{
writer.WriteByte((byte)TraceEntryTypes.StackAllocation);
writer.WriteInt32(Id);
writer.WriteInt32(InstructionImageId);
writer.WriteUInt32(InstructionRelativeAddress);
writer.WriteUInt32(Size);
writer.WriteUInt64(Address);
}
public static void SerializerMarshalFB <T>(T obj, Stream stream)
{
var output = new OutputStream(stream, 11);
var writer = new FastBinaryWriter <OutputStream>(output);
var serializer = new Serializer <FastBinaryWriter <OutputStream> >(typeof(T));
serializer.Marshal(obj, writer);
output.Flush();
}
internal static Frame MessageToFrame(ulong conversationId, string methodName, PayloadType type, IMessage payload, IBonded layerData, Logger logger)
{
var frame = new Frame(logger);
{
var headers = new EpoxyHeaders
{
conversation_id = conversationId,
payload_type = type,
method_name = methodName ?? string.Empty, // method_name is not nullable
};
if (payload.IsError)
{
headers.error_code = payload.Error.Deserialize <Error>().error_code;
}
else
{
headers.error_code = (int)ErrorCode.OK;
}
const int initialHeaderBufferSize = 150;
var outputBuffer = new OutputBuffer(initialHeaderBufferSize);
var fastWriter = new FastBinaryWriter <OutputBuffer>(outputBuffer);
Serialize.To(fastWriter, headers);
frame.Add(new Framelet(FrameletType.EpoxyHeaders, outputBuffer.Data));
}
if (layerData != null)
{
const int initialLayerDataBufferSize = 150;
var outputBuffer = new OutputBuffer(initialLayerDataBufferSize);
var compactWriter = new CompactBinaryWriter <OutputBuffer>(outputBuffer);
// TODO: See TODO below about issues with IBonded Marshal.TO(...)
compactWriter.WriteVersion();
layerData.Serialize(compactWriter);
frame.Add(new Framelet(FrameletType.LayerData, outputBuffer.Data));
}
{
var userData = payload.IsError ? (IBonded)payload.Error : (IBonded)payload.RawPayload;
const int initialPayloadBufferSize = 1024;
var outputBuffer = new OutputBuffer(initialPayloadBufferSize);
var compactWriter = new CompactBinaryWriter <OutputBuffer>(outputBuffer);
// TODO: marshal dies on IBonded Marshal.To(compactWriter, request)
// understand more deeply why and consider fixing
compactWriter.WriteVersion();
userData.Serialize(compactWriter);
frame.Add(new Framelet(FrameletType.PayloadData, outputBuffer.Data));
}
return(frame);
}
public override string Serialize(object serializable)
{
Initialize();
var output = new OutputBuffer(2 * 1024);
var writer = new FastBinaryWriter <OutputBuffer>(output);
_serializer.Serialize(serializable, writer);
return(Convert.ToBase64String(output.Data.Array, output.Data.Offset, output.Data.Count));
}
/// <summary>
/// Saves image file data.
/// </summary>
/// <param name="writer">Binary writer.</param>
public void Store(FastBinaryWriter writer)
{
writer.WriteInt32(Id);
writer.WriteUInt64(StartAddress);
writer.WriteUInt64(EndAddress);
writer.WriteInt32(Name.Length);
writer.WriteChars(Name.ToCharArray());
writer.WriteBoolean(Interesting);
}
public override void Serialize(object serializable, Stream outputStream)
{
Initialize();
//outputStream.Seek(0, SeekOrigin.Begin);
var output = new OutputStream(outputStream);
var writer = new FastBinaryWriter <OutputStream>(output);
_serializerStream.Serialize(serializable, writer);
output.Flush();
}
public virtual void WriteData(FastBinaryWriter writer, Object additionalInfo)
{
writer.Write(Caption ?? String.Empty);
writer.Write((Int16)Properties.Count);
foreach (String key in Properties.AllKeys)
{
writer.Write(key ?? String.Empty);
writer.Write(Properties[key] ?? String.Empty);
}
}
public void Store(FastBinaryWriter writer)
{
writer.WriteByte((byte)TraceEntryTypes.Branch);
writer.WriteInt32(SourceImageId);
writer.WriteUInt32(SourceInstructionRelativeAddress);
writer.WriteInt32(DestinationImageId);
writer.WriteUInt32(DestinationInstructionRelativeAddress);
writer.WriteBoolean(Taken);
writer.WriteByte((byte)BranchType);
}
public static byte[] Serialize <T>(T message)
{
var sizeOfMessage = SizeMapperManager.SizeOfMessage(message, true);
var fbw = new FastBinaryWriter(sizeOfMessage);
fbw.CreateContext(
ctx => Serialize(message, ctx));
return(fbw.Buffer);
}
public void Store(FastBinaryWriter writer)
{
writer.WriteByte((byte)TraceEntryTypes.HeapMemoryAccess);
writer.WriteBoolean(IsWrite);
writer.WriteInt16(Size);
writer.WriteInt32(InstructionImageId);
writer.WriteUInt32(InstructionRelativeAddress);
writer.WriteInt32(HeapAllocationBlockId);
writer.WriteUInt32(MemoryRelativeAddress);
}
