public void FromReader(FastBinaryReader reader)
{
IsWrite = reader.ReadBoolean();
InstructionImageId = reader.ReadInt32();
InstructionRelativeAddress = reader.ReadUInt32();
MemoryRelativeAddress = reader.ReadUInt32();
}
public virtual void ReadData(FastBinaryReader reader, Object additionalInfo)
{
// Version 5.0 data types
FSequenceID = reader.ReadInt32();
FSessionID = reader.ReadUInt32();
FRequestID = reader.ReadUInt32();
FSourceUtcOffset = reader.ReadInt16();
FDateTime = reader.ReadDateTime();
FDomainID = reader.ReadInt32();
FProcessID = reader.ReadInt32();
FThreadID = reader.ReadInt32();
FCategory = reader.ReadString();
FApplication = reader.ReadString();
FMachineName = reader.ReadString();
FUserDomainName = reader.ReadString();
FUserName = reader.ReadString();
FIndentLevel = reader.ReadSByte();
FBkColor = Color.FromArgb(reader.ReadInt32());
FMessageType = (MessageType)reader.ReadInt32();
FMessageSubType = reader.ReadByte();
FMessage = reader.ReadString();
FDetailType = reader.ReadInt32();
FExtPropertyContainer = reader.ReadObject <ReflectInsightPropertiesContainer>();
FSubDetails = reader.ReadObject <FastSerializerObjectData>();
FDetails = reader.ReadObject <FastSerializerObjectData>();
}
public void FastBinaryReader_Skip_String_NegativeLength_Throws()
{
var data = new byte[]
{
0x0a,
0x00,
0x00,
0x09,
0x02,
0x00,
0xff, // count -1
0xff,
0xff,
0xff,
0xff,
0x5a,
};
var input = new InputBuffer(data);
var reader = new FastBinaryReader <InputBuffer>(input);
Assert.Throws <OverflowException>(() => Deserialize <BondedAlias> .From(reader));
}
public override void ReadData(FastBinaryReader reader, Object additionalInfo)
{
Root = (RICustomData)reader.Tag;
base.ReadData(reader, additionalInfo);
Expanded = reader.ReadBoolean();
Caption = reader.ReadSafeString();
Children = new List <RICustomDataElement>();
Int32 elementCount = reader.ReadInt32();
for (Int32 i = 0; i < elementCount; i++)
{
Int32 elementTypeHash = reader.ReadInt32();
if (elementTypeHash == RICustomDataFieldTypeHash)
{
Children.Add(reader.ReadObject <RICustomDataField>());
}
else if (elementTypeHash == RICustomDataRowTypeHash)
{
Children.Add(reader.ReadObject <RICustomDataRow>());
}
else if (elementTypeHash == RICustomDataCategoryTypeHash)
{
Children.Add(reader.ReadObject <RICustomDataCategory>());
}
else if (elementTypeHash == RICustomDataContainerTypeHash)
{
Children.Add(reader.ReadObject <RICustomData>());
}
}
}
public void FasttBinaryReader_SkipContainer_OverflowLength_Throws(byte[] data)
{
var input = new InputBuffer(data);
var reader = new FastBinaryReader <InputBuffer>(input);
Assert.Throws <OverflowException>(() => Deserialize <BondClass <List <double> > > .From(reader));
}
public override void ReadData(FastBinaryReader reader, Object additionalInfo)
{
Root = (RICustomData)reader.Tag;
base.ReadData(reader, additionalInfo);
// Hint is no longer used. This line is left here for backward compatibility
reader.ReadSafeString();
ColumnPos = reader.ReadInt16();
Column = Root.Columns[ColumnPos];
Value = null;
if (!reader.IsNull())
{
switch (Column.FieldTypeId)
{
case RICustomDataFieldIdType.Decimal: Value = reader.ReadDecimal(); break;
case RICustomDataFieldIdType.Integer: Value = reader.ReadInt64(); break;
case RICustomDataFieldIdType.DateTime: Value = reader.ReadDateTime(); break;
case RICustomDataFieldIdType.Boolean: Value = reader.ReadBoolean(); break;
case RICustomDataFieldIdType.String: Value = reader.ReadString(); break;
case RICustomDataFieldIdType.Object: Value = reader.ReadString(); break;
case RICustomDataFieldIdType.Unknown: Value = reader.ReadString(); break;
default: break;
}
}
}
public void StepParser_ShouldTokenizeFileFast2(string path)
{
var sw = Stopwatch.StartNew();
using (var file = new FastBinaryReader(path))
{
var tokens = new int[Enum.GetValues(typeof(StepTokenKind)).Length];
StepTokenKind token;
var buffer = new FastStringBuilder();
while ((token = StepTokenizer.ReadNext(file, buffer)) != StepTokenKind.Eof)
{
tokens[(int)token]++;
}
Console.WriteLine(sw.ElapsedMilliseconds);
foreach (StepTokenKind kind in Enum.GetValues(typeof(StepTokenKind)))
{
Console.WriteLine($"{kind}: {tokens[(int)kind]}");
}
Console.WriteLine($"total: {tokens.Sum()}");
}
}
public static T DeserializeUnsafeFB <T>(ArraySegment <byte> data)
{
var input = new InputBuffer(data);
var reader = new FastBinaryReader <InputBuffer>(input);
return(Deserialize <T> .From(reader));
}
public static T DeserializePointerFB <T>(IntPtr data, int length)
{
var input = new InputPointer(data, length);
var reader = new FastBinaryReader <InputPointer>(input);
return(Deserialize <T> .From(reader));
}
protected override void Init(FastBinaryReader reader)
{
IsWrite = reader.ReadBoolean();
InstructionImageId = reader.ReadInt32();
InstructionRelativeAddress = reader.ReadUInt32();
MemoryRelativeAddress = reader.ReadUInt32();
}
public void FastBond()
{
var input = new InputBuffer(fastBondPersonBytes);
var reader = new FastBinaryReader <InputBuffer>(input);
fastBondDeserializer.Deserialize <Bond.Person>(reader);
}
public virtual void ReadData(FastBinaryReader reader, Object additionalInfo)
{
FColor = reader.ReadInt32();
FHue = reader.ReadByte();
FSaturation = reader.ReadByte();
FBrightness = reader.ReadByte();
}
internal static ClassifyState TransitionExpectEpoxyHeaders(
ClassifyState state, Frame frame, ref EpoxyHeaders headers, ref ProtocolErrorCode?errorCode, Logger logger)
{
Debug.Assert(state == ClassifyState.ExpectEpoxyHeaders);
Debug.Assert(frame != null);
if (frame.Count == 0 || frame.Framelets[0].Type != FrameletType.EpoxyHeaders)
{
return(ClassifyState.InternalStateError);
}
var framelet = frame.Framelets[0];
var inputBuffer = new InputBuffer(framelet.Contents);
var fastBinaryReader = new FastBinaryReader <InputBuffer>(inputBuffer, version: 1);
switch (headersDeserializer.TryDeserialize(fastBinaryReader, out headers))
{
case Deserialize.Result.Success:
break;
default:
logger.Site().Error("Didn't get a valid {0}.", nameof(EpoxyHeaders));
errorCode = ProtocolErrorCode.MALFORMED_DATA;
return(ClassifyState.MalformedFrame);
}
logger.Site().Debug("Deserialized {0} with conversation ID {1} and message type {2}.",
nameof(EpoxyHeaders), headers.conversation_id, headers.message_type);
return(ClassifyState.ExpectOptionalLayerData);
}
public static T DeserializeFB <T>(Stream stream)
{
var input = new InputStream(stream);
var reader = new FastBinaryReader <InputStream>(input);
return(Deserialize <T> .From(reader));
}
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 void FastBinaryReader_ShouldWorkForAllSizesSingleThreaded()
{
const int max = 10000;
var bytes = Enumerable.Range(0, max).Select(i => (byte)((i + 17) % 251)).ToArray();
for (int i = 1; i < max; i++)
{
using (var stream = new MemoryStream(bytes, 0, i))
{
using (var reader = new FastBinaryReader(stream, false))
{
int total = 0;
while (reader.Peek() != -1)
{
total++;
byte peek = (byte)reader.Peek();
byte read = (byte)reader.Read();
Assert.AreEqual(peek, read, "peek failed for byte " + total);
Assert.AreEqual(bytes[total - 1], peek, "read failed for byte " + total);
}
Assert.AreEqual(i, total, "Failed for i=" + i);
}
}
}
}
public static Gpw ParseGpw(string fileName)
{
if (GpwCache.TryGetValue(fileName, out Gpw gpw))
{
return(gpw);
}
using (FastBinaryReader br = VirtualFilesystem.Instance.GetFileStream(fileName))
{
gpw = new Gpw();
string header = br.ReadCString(4); // Always GAS0
gpw.AudioRange = (short)br.ReadUInt16();
ushort unk2 = br.ReadUInt16();
int unk3 = br.ReadInt32();
int unk4 = br.ReadInt32();
int unk5 = br.ReadInt32();
int unk6 = br.ReadInt32();
int unk7 = br.ReadInt32();
br.Position += 4; // Skip RIFF header
int waveFileSize = br.ReadInt32() + 8; // Read total size of audio data from RIFF header
br.Position -= 8; // Go back to RIFF header
byte[] audioData = br.ReadBytes(waveFileSize);
gpw.Clip = WavUtility.ToAudioClip(audioData, fileName);
GpwCache.Add(fileName, gpw);
return(gpw);
}
}
internal static ClassifyState TransitionExpectProtocolError(
ClassifyState state, Frame frame, ref ProtocolError error, ref FrameDisposition disposition, Logger logger)
{
if (state != ClassifyState.ExpectProtocolError || frame == null || frame.Count == 0 ||
frame.Framelets[0].Type != FrameletType.ProtocolError)
{
return(ClassifyState.InternalStateError);
}
if (frame.Count > 1)
{
logger.Site().Error("Protocol error frame had trailing framelets.");
return(ClassifyState.ErrorInErrorFrame);
}
var framelet = frame.Framelets[0];
var inputBuffer = new InputBuffer(framelet.Contents);
var fastBinaryReader = new FastBinaryReader <InputBuffer>(inputBuffer, version: 1);
switch (errorDeserializer.TryDeserialize(fastBinaryReader, out error))
{
case Deserialize.Result.Success:
break;
default:
logger.Site().Error("Didn't get a valid {0}.", nameof(ProtocolError));
return(ClassifyState.ErrorInErrorFrame);
}
logger.Site().Debug("Deserialized {0} with code {1}.", nameof(ProtocolError), error.error_code);
disposition = FrameDisposition.HandleProtocolError;
return(ClassifyState.ClassifiedValidFrame);
}
public override object Deserialize(string serialized)
{
Initialize();
var bytes = Convert.FromBase64String(serialized);
var input = new InputBuffer(bytes);
var reader = new FastBinaryReader<InputBuffer>(input);
return _deserializer.Deserialize(reader);
}
public virtual void ReadData(FastBinaryReader reader, Object additionalInfo)
{
FieldTypeId = (RICustomDataFieldIdType)reader.ReadInt32();
Justification = (RICustomDataColumnJustificationType)reader.ReadInt32();
Caption = reader.ReadSafeString();
Format = reader.ReadSafeString();
NullText = reader.ReadSafeString();
}
public void FromReader(FastBinaryReader reader)
{
Id = reader.ReadInt32();
InstructionImageId = reader.ReadInt32();
InstructionRelativeAddress = reader.ReadUInt32();
Size = reader.ReadUInt32();
Address = reader.ReadUInt64();
}
public virtual void ReadData(FastBinaryReader reader, Object additionalInfo)
{
// Version 5.0 data types
SessionId = reader.ReadUInt64();
RequestId = reader.ReadUInt64();
Sequence = reader.ReadInt16();
Chunk = reader.ReadByteArray();
}
public override object Deserialize(Stream inputStream)
{
Initialize();
inputStream.Seek(0, SeekOrigin.Begin);
var input = new InputStream(inputStream);
var reader = new FastBinaryReader<InputStream>(input);
return _deserializerStream.Deserialize(reader);
}
/// <summary>
/// Reads the data.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="additionalInfo">The additional information.</param>
public void ReadData(FastBinaryReader reader, object additionalInfo)
{
Nonce = new CryptoNonce()
{
Key = reader.ReadByteArray(),
IV = reader.ReadByteArray()
};
}
internal static void Read(FastBinaryReader parser)
{
var snapBytes = parser.readVarInt();
var msUsed = parser.readVarInt();
//if version > 5:
var bytesSent = parser.readVarInt();
var voiceBytesSent = parser.readVarInt();
}
public unsafe static T DeserializeUnsafeFBWithPtr <T>(Tuple <IntPtr, int> data)
{
byte *ptr = (byte *)data.Item1.ToPointer();
var input = new InputPtrBuffer(ptr, data.Item2);
var reader = new FastBinaryReader <InputPtrBuffer>(input);
return(Deserialize <T> .From(reader));
}
public IServiceRemotingRequestMessageBody Deserialize(IncomingMessageBody messageBody)
{
using (var stream = messageBody.GetReceivedBuffer())
{
var reader = new FastBinaryReader <InputStream>(new InputStream(stream));
return(_deserializer.Deserialize(reader) as IServiceRemotingRequestMessageBody);
}
}
public override object Deserialize(Stream inputStream)
{
Initialize();
inputStream.Seek(0, SeekOrigin.Begin);
var input = new InputStream(inputStream);
var reader = new FastBinaryReader <InputStream>(input);
return(_deserializerStream.Deserialize(reader));
}
public override object Deserialize(string serialized)
{
Initialize();
var bytes = Convert.FromBase64String(serialized);
var input = new InputBuffer(bytes);
var reader = new FastBinaryReader <InputBuffer>(input);
return(_deserializer.Deserialize(reader));
}
public void FromReader(FastBinaryReader reader)
{
SourceImageId = reader.ReadInt32();
SourceInstructionRelativeAddress = reader.ReadUInt32();
DestinationImageId = reader.ReadInt32();
DestinationInstructionRelativeAddress = reader.ReadUInt32();
Taken = reader.ReadBoolean();
BranchType = (BranchTypes)reader.ReadByte();
}
public virtual void ReadData(FastBinaryReader reader, Object additionalInfo)
{
FFilterInfo = reader.ReadObject <FilterInfo>();
FFilterDefined = reader.ReadBoolean();
FMessages = ReadBooleanArray(reader);
FCheckpoints = ReadBooleanArray(reader);
FCheckmarks = ReadBooleanArray(reader);
FLevels = ReadBooleanArray(reader);
}
protected override void Init(FastBinaryReader reader)
{
SourceImageId = reader.ReadInt32();
SourceInstructionRelativeAddress = reader.ReadUInt32();
DestinationImageId = reader.ReadInt32();
DestinationInstructionRelativeAddress = reader.ReadUInt32();
Taken = reader.ReadBoolean();
BranchType = (BranchTypes)reader.ReadByte();
}
public void MakeProtocolErrorFrame_JustErrorCode_MakesAFrame()
{
var frame = EpoxyConnection.MakeProtocolErrorFrame(MeaninglessErrorCode, null, LoggerTests.BlackHole);
Assert.NotNull(frame);
Assert.AreEqual(1, frame.Framelets.Count);
Assert.AreEqual(FrameletType.ProtocolError, frame.Framelets[0].Type);
var inputBuffer = new InputBuffer(frame.Framelets[0].Contents);
var fastBinaryReader = new FastBinaryReader<InputBuffer>(inputBuffer, version: 1);
var error = Deserialize<ProtocolError>.From(fastBinaryReader);
Assert.AreEqual(MeaninglessErrorCode, error.error_code);
Assert.Null(error.details);
}
public void MakeProtocolErrorFrame_WithDetails_MakesAFrame()
{
var frame = EpoxyConnection.MakeProtocolErrorFrame(MeaninglessErrorCode, AnyDetails, LoggerTests.BlackHole);
Assert.NotNull(frame);
Assert.AreEqual(1, frame.Framelets.Count);
Assert.AreEqual(FrameletType.ProtocolError, frame.Framelets[0].Type);
var inputBuffer = new Bond.IO.Unsafe.InputBuffer(frame.Framelets[0].Contents);
var fastBinaryReader = new FastBinaryReader<InputBuffer>(inputBuffer, version: 1);
var error = Deserialize<ProtocolError>.From(fastBinaryReader);
Assert.AreEqual(MeaninglessErrorCode, error.error_code);
Assert.NotNull(error.details);
var details = error.details.Deserialize();
Assert.IsTrue(AnyDetails.IsEqual<Error, Error>(details));
}
internal static ClassifyState TransitionExpectEpoxyHeaders(
ClassifyState state, Frame frame, ref EpoxyHeaders headers, ref ProtocolErrorCode? errorCode, Logger logger)
{
Debug.Assert(state == ClassifyState.ExpectEpoxyHeaders);
Debug.Assert(frame != null);
if (frame.Count == 0 || frame.Framelets[0].Type != FrameletType.EpoxyHeaders)
{
return ClassifyState.InternalStateError;
}
var framelet = frame.Framelets[0];
var inputBuffer = new InputBuffer(framelet.Contents);
var fastBinaryReader = new FastBinaryReader<InputBuffer>(inputBuffer, version: 1);
switch (headersDeserializer.TryDeserialize(fastBinaryReader, out headers))
{
case Deserialize.Result.Success:
break;
default:
logger.Site().Error("Didn't get a valid {0}.", nameof(EpoxyHeaders));
errorCode = ProtocolErrorCode.MALFORMED_DATA;
return ClassifyState.MalformedFrame;
}
logger.Site().Debug("Deserialized {0} with conversation ID {1} and message type {2}.",
nameof(EpoxyHeaders), headers.conversation_id, headers.message_type);
return ClassifyState.ExpectOptionalLayerData;
}
internal static ClassifyState TransitionExpectConfig(
ClassifyState state, Frame frame, ref ProtocolErrorCode? errorCode, ref FrameDisposition disposition,
Logger logger)
{
Debug.Assert(state == ClassifyState.ExpectConfig);
Debug.Assert(frame != null);
if (frame.Count == 0 || frame.Framelets[0].Type != FrameletType.EpoxyConfig)
{
return ClassifyState.InternalStateError;
}
if (frame.Count != 1)
{
logger.Site().Error("Config frame had trailing framelets.");
errorCode = ProtocolErrorCode.MALFORMED_DATA;
return ClassifyState.MalformedFrame;
}
var framelet = frame.Framelets[0];
var inputBuffer = new InputBuffer(framelet.Contents);
var fastBinaryReader = new FastBinaryReader<InputBuffer>(inputBuffer, version: 1);
// We don't currently do anything with the config aside from try to deserialize it.
EpoxyConfig config;
switch (configDeserializer.TryDeserialize(fastBinaryReader, out config))
{
case Deserialize.Result.Success:
break;
default:
logger.Site().Error("Didn't get a valid {0}.", nameof(EpoxyConfig));
errorCode = ProtocolErrorCode.MALFORMED_DATA;
return ClassifyState.MalformedFrame;
}
disposition = FrameDisposition.ProcessConfig;
return ClassifyState.ClassifiedValidFrame;
}
internal static ClassifyState TransitionExpectProtocolError(
ClassifyState state, Frame frame, ref ProtocolError error, ref FrameDisposition disposition, Logger logger)
{
if (state != ClassifyState.ExpectProtocolError || frame == null || frame.Count == 0
|| frame.Framelets[0].Type != FrameletType.ProtocolError)
{
return ClassifyState.InternalStateError;
}
if (frame.Count > 1)
{
logger.Site().Error("Protocol error frame had trailing framelets.");
return ClassifyState.ErrorInErrorFrame;
}
var framelet = frame.Framelets[0];
var inputBuffer = new InputBuffer(framelet.Contents);
var fastBinaryReader = new FastBinaryReader<InputBuffer>(inputBuffer, version: 1);
switch (errorDeserializer.TryDeserialize(fastBinaryReader, out error))
{
case Deserialize.Result.Success:
break;
default:
logger.Site().Error("Didn't get a valid {0}.", nameof(ProtocolError));
return ClassifyState.ErrorInErrorFrame;
}
logger.Site().Debug("Deserialized {0} with code {1}.", nameof(ProtocolError), error.error_code);
disposition = FrameDisposition.HandleProtocolError;
return ClassifyState.ClassifiedValidFrame;
}
