static void BytesReaderBenchmarkBaseline()
{
int sections = 10;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < sections; i++)
{
sb.Append("123456789012345678\r\n");
}
var data = Encoding.UTF8.GetBytes(sb.ToString());
var eol = new Span <byte>(s_eol);
var bytes = new ReadOnlyBytes(data);
var reader = BytesReader.Create(bytes);
while (true)
{
var range = reader.ReadRange(eol);
if (range.To == Position.End)
{
break;
}
}
}
public void MultiSegmentBytesReader()
{
ReadOnlyBytes bytes = Parse("A|B |CD|#EF&|&");
var reader = new BytesReader(bytes);
var ab = reader.ReadBytesUntil((byte)' ');
Assert.Equal("AB", ab.ToString(SymbolTable.InvariantUtf8));
Assert.Equal(2, reader.Index);
reader.Advance(1);
Assert.Equal(3, reader.Index);
var cd = reader.ReadBytesUntil((byte)'#');
Assert.Equal("CD", cd.ToString(SymbolTable.InvariantUtf8));
Assert.Equal(5, reader.Index);
reader.Advance(1);
Assert.Equal(6, reader.Index);
var ef = reader.ReadBytesUntil(new byte[] { (byte)'&', (byte)'&' });
Assert.Equal("EF", ef.ToString(SymbolTable.InvariantUtf8));
Assert.Equal(8, reader.Index);
reader.Advance(2);
Assert.Equal(10, reader.Index);
}
public void MultiSegmentBytesReaderNumbers()
{
ReadOnlyBytes bytes = ListHelper.CreateRob(new byte[][] {
new byte[] { 0 },
new byte[] { 1, 2 },
new byte[] { 3, 4 },
new byte[] { 5, 6, 7, 8 },
new byte[] { 8, 0 },
new byte[] { 1, },
new byte[] { 0, 2, },
new byte[] { 1, 2, 3, 4 },
});
var reader = BytesReader.Create(bytes);
var span = bytes.Slice(reader.ReadRange(2)).ToSpan();
Assert.Equal(0, span[0]);
Assert.Equal(1, span[1]);
span = bytes.Slice(reader.ReadRange(5)).ToSpan();
Assert.Equal(3, span[0]);
Assert.Equal(4, span[1]);
span = bytes.Slice(reader.ReadRange(new byte[] { 8, 8 })).ToSpan();
Assert.Equal(6, span[0]);
Assert.Equal(7, span[1]);
Assert.True(reader.TryRead(out int value, true));
Assert.Equal(BitConverter.ToInt32(new byte[] { 0, 1, 0, 2 }), value);
Assert.True(reader.TryRead(out value));
Assert.Equal(BitConverter.ToInt32(new byte[] { 4, 3, 2, 1 }), value);
}
public static void RunWithOptions(CmdOptions options)
{
var validator = new CmdOptionsValidator(options);
validator.Validate();
var bytesReader = new BytesReader(options.NumberOfBytes);
var attr = File.GetAttributes(options.Path);
if (!attr.HasFlag(FileAttributes.Directory))
{
RunForSingleFile(bytesReader, options);
return;
}
var fileWalker = new FileWalker(options.Path, options.Recursive, options.MaxDepth);
var runner = new Runner(
bytesReader,
fileWalker,
options.Separator,
options.BytesSeparator);
runner.Run();
}
private void OnGetInfo(Beetle.IChannel channel, string appname, IProperties properties)
{
HttpHeader result;
TrackerInfo info;
byte[] data;
BytesReader reader;
HttpBody body;
IAppTrackerHandler appHandler = GetAppHandler(appname);
if (appHandler == null)
{
result = new HttpHeader();
result.Action = "500 " + string.Format("{0} Tracker Handler Notfound", appname);
channel.Send(result);
}
else
{
info = appHandler.GetInfo(properties);
data = Encoding.UTF8.GetBytes(info.Data);
result = new HttpHeader();
result.Action = "200";
result.Length = data.Length;
result[Protocol.HEADER_INFOTYPE] = info.TypeName;
channel.Send(result);
reader = new BytesReader(data, 0, data.Length);
while (reader.Read())
{
body = HttpPacket.InstanceBodyData();
reader.ReadTo(body);
channel.Send(body);
}
}
}
public static HttpRequest Parse(ReadOnlyBytes bytes)
{
var request = new HttpRequest();
request.Bytes = bytes;
var reader = new BytesReader(bytes);
Range?verb = reader.ReadRangeUntil((byte)' ');
request._verb = verb.Value;
reader.Advance(1);
Range?path = reader.ReadRangeUntil((byte)' ');
request._path = path.Value;
reader.Advance(1);
Range?version = reader.ReadRangeUntil(Cr);
request._version = version.Value;
reader.Advance(2);
var headers = reader.ReadRangeUntil(Cr2).Value;
request._headers = new HttpHeaders()
{
_headers = bytes.Slice(headers.Index, headers.Length + 2)
};
request._bodyIndex = headers.Index + headers.Length + 4;
return(request);
}
public void BytesReaderParse()
{
ulong u64;
bool b;
ReadOnlyBytes bytes = Parse("12|3Tr|ue|456Tr|ue7|89False|");
var reader = new BytesReader(bytes);
Assert.True(reader.TryParseUInt64(out u64));
Assert.Equal(123ul, u64);
Assert.True(reader.TryParseBoolean(out b));
Assert.Equal(true, b);
Assert.True(reader.TryParseUInt64(out u64));
Assert.Equal(456ul, u64);
Assert.True(reader.TryParseBoolean(out b));
Assert.Equal(true, b);
Assert.True(reader.TryParseUInt64(out u64));
Assert.Equal(789ul, u64);
Assert.True(reader.TryParseBoolean(out b));
Assert.Equal(false, b);
//Assert.True(reader.IsEmpty);
}
public void Read(BytesReader buffer)
{
id = buffer.ReadInt32();
type = buffer.ReadInt32();
localX = buffer.ReadFloat();
localY = buffer.ReadFloat();
isRoot = buffer.ReadInt32();
grids.Clear();
int numOfGrids = buffer.ReadInt32();
for (int i = 0; i < MaxGrid; i++)
{
int col = buffer.ReadInt32();
int row = buffer.ReadInt32();
if (i < numOfGrids)
{
grids.Add(new GridPosition(col, row));
}
}
connections.Clear();
int numOfConnection = buffer.ReadInt32();
for (int i = 0; i < MaxConnection; i++)
{
int n = buffer.ReadInt32();
if (i < numOfConnection)
{
connections.Add(n);
}
}
}
static void BytesReaderBenchmarkBaseline()
{
int sections = 10;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < sections; i++)
{
sb.Append("123456789012345678\r\n");
}
var data = Encoding.UTF8.GetBytes(sb.ToString());
var eol = new Span <byte>(s_eol);
var bytes = new ReadOnlyBytes(data);
var reader = new BytesReader(bytes, TextEncoder.Utf8);
while (true)
{
var result = reader.ReadBytesUntil(eol);
if (result == null)
{
break;
}
reader.Advance(2);
}
}
public void MultiSegmentBytesReaderNumbers()
{
ReadOnlyBytes bytes = ReadOnlyBytes.Create(new byte[][] {
new byte[] { 0 },
new byte[] { 1, 2 },
new byte[] { 3, 4 },
new byte[] { 5, 6, 7, 8 },
new byte[] { 8 }
});
var reader = new BytesReader(bytes);
var value = reader.ReadBytesUntil(2).Value.ToSpan();
Assert.Equal(0, value[0]);
Assert.Equal(1, value[1]);
reader.Advance(1);
value = reader.ReadBytesUntil(5).Value.ToSpan();
Assert.Equal(3, value[0]);
Assert.Equal(4, value[1]);
reader.Advance(1);
value = reader.ReadBytesUntil(new byte[] { 8, 8 }).Value.ToSpan();
Assert.Equal(6, value[0]);
Assert.Equal(7, value[1]);
reader.Advance(2);
//Assert.True(reader.IsEmpty);
}
public void EmptyBytesReader()
{
ReadOnlyBytes bytes = Create("");
var reader = BytesReader.Create(bytes);
Assert.False(reader.TryReadBytes(out var range, (byte)' '));
bytes = Parse("|");
reader = BytesReader.Create(bytes);
Assert.False(reader.TryReadBytes(out range, (byte)' '));
}
public void EmptyBytesReader()
{
ReadOnlyBytes bytes = Create("");
var reader = BytesReader.Create(bytes);
var range = reader.ReadRange((byte)' ');
Assert.Equal(Position.End, range.To);
bytes = Parse("|");
reader = BytesReader.Create(bytes);
range = reader.ReadRange((byte)' ');
Assert.Equal(Position.End, range.To);
}
public void SingleSegmentBytesReader()
{
ReadOnlyBytes bytes = Create("AB CD#EF&&");
var reader = BytesReader.Create(bytes);
Assert.True(reader.TryReadBytes(out var ab, (byte)' '));
Assert.Equal("AB", ab.ToString(SymbolTable.InvariantUtf8));
Assert.True(reader.TryReadBytes(out var cd, (byte)'#'));
Assert.Equal("CD", cd.ToString(SymbolTable.InvariantUtf8));
Assert.True(reader.TryReadBytes(out var ef, new byte[] { (byte)'&', (byte)'&' }));
Assert.Equal("EF", ef.ToString(SymbolTable.InvariantUtf8));
}
public void MultiSegmentBytesReader()
{
ReadOnlyBytes bytes = Parse("A|B |CD|#EF&|&");
var reader = BytesReader.Create(bytes);
Assert.True(reader.TryReadBytes(out var ab, (byte)' '));
Assert.Equal("AB", ab.Utf8ToString());
Assert.True(reader.TryReadBytes(out var cd, (byte)'#'));
Assert.Equal("CD", cd.Utf8ToString());
//Assert.True(reader.TryReadBytes(out var ef, new byte[] { (byte)'&', (byte)'&' }));
//Assert.Equal("EF", ef.ToString(SymbolTable.InvariantUtf8));
}
static void ParseInt32BytesReader()
{
foreach (var iteration in Benchmark.Iterations)
{
var reader = BytesReader.Create(s_bytes);
using (iteration.StartMeasurement()) {
while (reader.TryParse(out int value))
{
reader.Advance(1);
}
}
}
}
public void EmptyBytesReader()
{
ReadOnlyBytes bytes = Create("");
var reader = new BytesReader(bytes);
var found = reader.ReadBytesUntil((byte)' ');
Assert.Equal("", found.ToString(TextEncoder.Utf8));
bytes = Parse("|");
reader = new BytesReader(bytes);
found = reader.ReadBytesUntil((byte)' ');
Assert.Equal("", found.ToString(TextEncoder.Utf8));
//Assert.True(reader.IsEmpty);
}
private bool ReadHeader(BytesReader buffer)
{
uint flag = buffer.ReadUInt32();
if (flag != HeaderFlag)
{
return(false);
}
mapType = (ELevelMapType)buffer.ReadInt32();
minCol = buffer.ReadInt32();
maxBallId = buffer.ReadInt32();
ballRadius = buffer.ReadFloat();
return(true);
}
public void MultiSegmentBytesReader()
{
ReadOnlyBytes bytes = Parse("A|B |CD|#EF&|&");
var reader = BytesReader.Create(bytes);
var ab = bytes.Slice(reader.ReadRange((byte)' '));
Assert.Equal("AB", ab.ToString(SymbolTable.InvariantUtf8));
var cd = bytes.Slice(reader.ReadRange((byte)'#'));
Assert.Equal("CD", cd.ToString(SymbolTable.InvariantUtf8));
var ef = bytes.Slice(reader.ReadRange(new byte[] { (byte)'&', (byte)'&' }));
Assert.Equal("EF", ef.ToString(SymbolTable.InvariantUtf8));
}
private void Start()
{
node = new APNode(signalingServer);
node.OnServerStartSuccess += () => {
msg1.text = "Server started";
};
node.OnServerStartFailure += e => {
msg1.text = "Server start failed " + e;
};
node.OnServerStop += () => {
msg1.text = "Stopped server";
msg2.text = "";
};
node.OnConnected += () => {
msg1.text = "Connected to server";
};
node.OnReceiveID += id => Debug.Log("Got ID : " + id);
node.OnDisconnected += () =>
msg1.text = "Disconnected from server";
node.OnConnectionFailed += ex =>
Debug.LogError(ex);
node.OnPacketReceived += (id, packet) => {
var reader = new BytesReader(packet.Payload);
msg2.text = "Received " + reader.ReadInt();
};
node.OnClientJoined += id =>
Debug.Log("Client joined : " + id);
node.OnClientLeft += id =>
Debug.Log("Client left : " + id);
}
void Init()
{
node.OnServerStartSuccess += () => OnCreatedChatroom?.Invoke();
node.OnServerStartFailure += e =>
OnChatroomCreationFailed?.Invoke(e);
node.OnServerStop += () => OnlosedChatroom?.Invoke();
node.OnConnectionFailed += ex => OnChatroomJoinFailed?.Invoke(ex);
node.OnReceiveID += id => {
if (id != 0)
{
OnJoinedChatroom?.Invoke(id);
OnPeerJoinedChatroom?.Invoke(0); // server joins instantly
}
};
node.OnDisconnected += () => OnLeftChatroom?.Invoke();
node.OnRemoteServerClosed += () => OnLeftChatroom?.Invoke();
node.OnClientJoined += id => OnPeerJoinedChatroom?.Invoke(id);
node.OnClientLeft += id => OnPeerLeftChatroom?.Invoke(id);
node.OnPacketReceived += (sender, packet) => {
if (packet.Tag.Equals("audio"))
{
var reader = new BytesReader(packet.Payload);
var index = reader.ReadInt();
var frequency = reader.ReadInt();
var channels = reader.ReadInt();
var samples = reader.ReadFloatArray();
OnAudioReceived?.Invoke(new ChatroomAudioDTO {
id = sender,
segmentIndex = index,
frequency = frequency,
channelCount = channels,
samples = samples
});
}
};
}
void Start()
{
var writer = new BytesWriter();
writer.WriteInt(90);
writer.WriteString("Vatsal");
writer.WriteString("Adrenak");
writer.WriteString("Ambastha");
writer.WriteVector3(Vector3.one);
writer.WriteFloatArray(new[] { 1.1f, 2.2f, 3.3f });
var reader = new BytesReader(writer.Bytes);
// READ IN THE SAME ORDER
Debug.Log(reader.ReadInt());
Debug.Log(reader.ReadString());
Debug.Log(reader.ReadString());
Debug.Log(reader.ReadString());
Debug.Log(reader.ReadVector3());
Debug.Log("Floats : " + string.Join(", ", reader.ReadFloatArray()));
}
static void BytesReaderBasic()
{
var eol = new ReadOnlySpan <byte>(s_eol);
foreach (var iteration in Benchmark.Iterations)
{
var reader = new BytesReader(s_bytes, SymbolTable.InvariantUtf8);
using (iteration.StartMeasurement())
{
while (true)
{
var result = reader.ReadRangeUntil(eol);
if (result == null)
{
break;
}
reader.Advance(eol.Length);
}
}
}
}
private bool ReadBalls(BytesReader buffer)
{
uint flag = buffer.ReadUInt32();
if (flag != BallFlag)
{
return(false);
}
int numOfBall = buffer.ReadInt32();
if (numOfBall > 0)
{
for (int i = 0; i < numOfBall; i++)
{
BallData ball = new BallData();
ball.Read(buffer);
balls.Add(ball);
}
}
return(true);
}
public void MultiSegmentBytesReader()
{
ReadOnlyBytes bytes = Parse("A|B |CD|#EF&|&");
var reader = new BytesReader(bytes);
var ab = reader.ReadBytesUntil((byte)' ');
Assert.Equal("AB", ab.ToString(TextEncoder.Utf8));
reader.Advance(1);
var cd = reader.ReadBytesUntil((byte)'#');
Assert.Equal("CD", cd.ToString(TextEncoder.Utf8));
reader.Advance(1);
var ef = reader.ReadBytesUntil(new byte[] { (byte)'&', (byte)'&' });
Assert.Equal("EF", ef.ToString(TextEncoder.Utf8));
reader.Advance(2);
//Assert.True(reader.IsEmpty);
}
public void BytesReaderParse()
{
ReadOnlyBytes bytes = Parse("12|3Tr|ue|456Tr|ue7|89False|");
var reader = BytesReader.Create(bytes);
Assert.True(reader.TryParse(out ulong u64));
Assert.Equal(123ul, u64);
Assert.True(reader.TryParse(out bool b));
Assert.Equal(true, b);
Assert.True(reader.TryParse(out u64));
Assert.Equal(456ul, u64);
Assert.True(reader.TryParse(out b));
Assert.Equal(true, b);
Assert.True(reader.TryParse(out u64));
Assert.Equal(789ul, u64);
Assert.True(reader.TryParse(out b));
Assert.Equal(false, b);
}
static void BytesReaderBenchmarkBaseline()
{
int sections = 10;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < sections; i++)
{
sb.Append("1234 ");
}
var data = Encoding.UTF8.GetBytes(sb.ToString());
var readOnlyBytes = new ReadOnlyBytes(data);
var bytesRange = new ReadOnlyBytes(data);
var robReader = BytesReader.Create(readOnlyBytes);
long robSum = 0;
while (robReader.TryParse(out int value))
{
robSum += value;
robReader.Advance(1);
}
var brReader = BytesReader.Create(bytesRange);
long brSum = 0;
while (brReader.TryParse(out int value))
{
brSum += value;
brReader.Advance(1);
}
Assert.Equal(robSum, brSum);
Assert.NotEqual(brSum, 0);
}
public bool LoadFromBytes(byte[] data)
{
balls.Clear();
try
{
BytesReader buffer = new BytesReader(data);
uint flag = buffer.ReadUInt32();
int version = buffer.ReadInt32();
if (flag != FileFlag || version != FileVersion)
{
Debug.LogError("LevelMapData format error.");
return(false);
}
if (!ReadHeader(buffer))
{
Debug.LogError("Level file format error.");
return(false);
}
if (!ReadBalls(buffer))
{
Debug.LogError("Level file format error.");
return(false);
}
return(true);
}
catch
{
return(false);
}
}
public void SingleSegmentBytesReader()
{
ReadOnlyBytes bytes = Create("AB CD#EF&&");
var reader = new BytesReader(bytes);
var ab = reader.ReadBytesUntil((byte)' ');
Assert.True(ab.HasValue);
Assert.Equal("AB", ab.ToString(TextEncoder.Utf8));
reader.Advance(1);
var cd = reader.ReadBytesUntil((byte)'#');
Assert.Equal("CD", cd.ToString(TextEncoder.Utf8));
reader.Advance(1);
var ef = reader.ReadBytesUntil(new byte[] { (byte)'&', (byte)'&' });
Assert.Equal("EF", ef.ToString(TextEncoder.Utf8));
reader.Advance(2);
//Assert.True(reader.IsEmpty);
}
public BytesPipe(IBytesPool bytesPool)
{
_state = new BytesState(bytesPool);
_reader = new BytesReader(_state);
_writer = new BytesWriter(_state);
}
public UnknownSizeGZipChunkReader(Stream stream)
{
_stream = stream ?? throw new ArgumentNullException(nameof(stream));
_reader = new BytesReader(_stream);
GZipHeaderSignature = GetFirstHeaderSignature();
}
