public void Rewind_ByOne()
{
ReadOnlySequence <byte> bytes = SequenceFactory.Create(new byte[][] {
new byte[] { 0 },
new byte[] { 1, 2 },
new byte[] { 3, 4 },
new byte[] { 5, 6, 7, 8 }
});
ByteBufferReader reader = new ByteBufferReader(bytes);
reader.Advance(1);
ByteBufferReader copy = reader;
for (int i = 1; i < bytes.Length; i++)
{
reader.Advance(i);
Assert.Equal(i + 1, reader.Consumed);
for (int j = 0; j < i; j++)
{
reader.Rewind(1);
Assert.Equal(i - j, reader.Consumed);
Assert.False(reader.End);
}
Assert.Equal(copy.Position, reader.Position);
Assert.Equal(copy.Consumed, reader.Consumed);
Assert.Equal(copy.CurrentSpanIndex, reader.CurrentSpanIndex);
Assert.Equal(copy.End, reader.End);
Assert.True(copy.CurrentSpan.SequenceEqual(reader.CurrentSpan));
}
}
public void TryReadToSpan_Sequence(bool advancePastDelimiter)
{
ReadOnlySequence <byte> bytes = SequenceFactory.Create(new byte[][] {
new byte[] { 0, 0 },
new byte[] { 1, 1, 2, 2 },
new byte[] { },
new byte[] { 3, 3, 4, 4, 5, 5, 6, 6 }
});
ByteBufferReader reader = new ByteBufferReader(bytes);
for (byte i = 0; i < bytes.Length / 2 - 1; i++)
{
byte[] expected = new byte[i * 2 + 1];
for (int j = 0; j < expected.Length - 1; j++)
{
expected[j] = (byte)(j / 2);
}
expected[i * 2] = i;
ReadOnlySpan <byte> searchFor = new byte[] { i, (byte)(i + 1) };
ByteBufferReader copy = reader;
Assert.True(copy.TryReadTo(out ReadOnlySequence <byte> seq, searchFor, advancePastDelimiter));
Assert.True(seq.ToArray().AsSpan().SequenceEqual(expected));
}
bytes = SequenceFactory.Create(new byte[][] {
new byte[] { 47, 42, 66, 32, 42, 32, 66, 42, 47 } // /*b * b*/
});
reader = new ByteBufferReader(bytes);
Assert.True(reader.TryReadTo(out ReadOnlySequence <byte> sequence, new byte[] { 42, 47 }, advancePastDelimiter)); // */
Assert.True(sequence.ToArray().AsSpan().SequenceEqual(new byte[] { 47, 42, 66, 32, 42, 32, 66 }));
}
public void TryReadReturnsValueAndAdvances()
{
ByteBufferReader reader = new ByteBufferReader(Factory.CreateWithContent(GetInputData(2)));
Assert.Equal(2, reader.Length);
Assert.Equal(2, reader.Remaining);
Assert.Equal(0, reader.Consumed);
Assert.Equal(0, reader.CurrentSpanIndex);
Assert.Equal(InputData[0], reader.CurrentSpan[reader.CurrentSpanIndex]);
// Read 1st value
Assert.True(reader.TryRead(out byte value));
Assert.Equal(InputData[0], value);
Assert.Equal(1, reader.Remaining);
Assert.Equal(1, reader.Consumed);
Assert.Equal(1, reader.CurrentSpanIndex);
Assert.Equal(InputData[1], reader.CurrentSpan[reader.CurrentSpanIndex]);
// Read 2nd value
Assert.True(reader.TryRead(out value));
Assert.Equal(InputData[1], value);
Assert.Equal(0, reader.Remaining);
Assert.Equal(2, reader.Consumed);
Assert.Equal(2, reader.CurrentSpanIndex);
// Read at end
Assert.False(reader.TryRead(out value));
Assert.Equal(default, value);
public int Read(ByteBufferReader reader)
{
BlockHeader header = new BlockHeader(reader);
vertexCount = reader.ReadInt();
reader.ReadInt(); //normal count
reader.ReadInt(); //offset
vertexData = new VertexData[vertexCount];
normalCounts = new int[vertexCount];
normals = new List <Vector3>();
for (int i = 0; i < normalCounts.Length; i++)
{
normalCounts[i] = reader.ReadByte();
}
for (int i = 0; i < vertexCount; i++)
{
int normalCountForVertex = normalCounts[i];
vertexData[i].vertex = reader.ReadVector3();
vertexData[i].normals = new Vector3[normalCountForVertex];
for (int j = 0; j < normalCountForVertex; j++)
{
Vector3 normal = reader.ReadVector3();
vertexData[i].normals[j] = normal;
normals.Add(normal);
}
}
return(header.size);
}
public void AdvanceSingleBufferSkipsValues()
{
ByteBufferReader reader = new ByteBufferReader(SequenceFactory.Create(GetInputData(5)));
Assert.Equal(5, reader.Length);
Assert.Equal(5, reader.Remaining);
Assert.Equal(0, reader.Consumed);
Assert.Equal(0, reader.CurrentSpanIndex);
// Advance 2 positions
reader.Advance(2);
Assert.Equal(5, reader.Length);
Assert.Equal(3, reader.Remaining);
Assert.Equal(2, reader.Consumed);
Assert.Equal(2, reader.CurrentSpanIndex);
Assert.Equal(InputData[2], reader.CurrentSpan[reader.CurrentSpanIndex]);
Assert.True(reader.TryPeek(out byte value));
Assert.Equal(InputData[2], value);
// Advance 2 positions
reader.Advance(2);
Assert.Equal(1, reader.Remaining);
Assert.Equal(4, reader.Consumed);
Assert.Equal(4, reader.CurrentSpanIndex);
Assert.Equal(InputData[4], reader.CurrentSpan[reader.CurrentSpanIndex]);
Assert.True(reader.TryPeek(out value));
Assert.Equal(InputData[4], value);
}
public static string DumpConditionalIntExpression(ByteBufferReader reader)
{
var op = reader[1].ReadByte();
switch (op)
{
case 0:
{
var count = reader[2].ReadUInt16();
var sb = new StringBuilder();
for (int i = 0, j = 0; i < count; i++, j += 2)
{
if (i > 0)
{
sb.Append(" + ");
}
var subReader = reader[reader[j + 4].ReadUInt16() + 4];
sb.Append(DumpConditionalInt(subReader));
}
return(sb.ToString());
}
default:
{
throw new NotImplementedException();
}
}
}
public GeometryParser(byte[] bspBytes)
{
reader = new ByteBufferReader(bspBytes);
points = new PointDefinitions();
polygonGroups = new List <PolygonGroup>();
ParseBSPTree();
}
public void IsNext_Span()
{
ReadOnlySequence <byte> bytes = BufferFactory.Create(new byte[][] {
new byte[] { 0 },
new byte[] { 1, 2 },
new byte[] { 3, 4 },
new byte[] { 5, 6, 7, 8 }
});
ByteBufferReader reader = new ByteBufferReader(bytes);
Assert.True(reader.IsNext(ReadOnlySpan <byte> .Empty, advancePast: false));
Assert.True(reader.IsNext(ReadOnlySpan <byte> .Empty, advancePast: true));
Assert.True(reader.IsNext(new byte[] { 0 }, advancePast: false));
Assert.False(reader.IsNext(new byte[] { 0, 2 }, advancePast: false));
Assert.False(reader.IsNext(new byte[] { 0, 2 }, advancePast: true));
Assert.True(reader.IsNext(new byte[] { 0, 1 }, advancePast: false));
Assert.False(reader.IsNext(new byte[] { 0, 1, 3 }, advancePast: false));
Assert.True(reader.IsNext(new byte[] { 0, 1, 2 }, advancePast: false));
Assert.False(reader.IsNext(new byte[] { 0, 1, 2, 4 }, advancePast: false));
Assert.True(reader.IsNext(new byte[] { 0, 1, 2, 3 }, advancePast: false));
Assert.True(reader.IsNext(new byte[] { 0, 1, 2, 3, 4 }, advancePast: false));
Assert.True(reader.IsNext(new byte[] { 0, 1, 2, 3, 4, 5 }, advancePast: false));
Assert.True(reader.IsNext(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 }, advancePast: false));
Assert.False(reader.IsNext(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, advancePast: false));
Assert.False(reader.IsNext(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, advancePast: true));
Assert.Equal(0, reader.Consumed);
Assert.True(reader.IsNext(new byte[] { 0, 1, 2, 3 }, advancePast: true));
Assert.True(reader.IsNext(new byte[] { 4, 5, 6 }, advancePast: true));
Assert.True(reader.TryPeek(out byte value));
Assert.Equal(7, value);
}
public void SkipTests(bool singleSegment)
{
byte[] buffer = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var bytes = singleSegment
? new ReadOnlySequence <byte>(buffer)
: BufferUtilities.CreateSplitBuffer(buffer, 2, 4);
var skipReader = new ByteBufferReader(bytes);
Assert.False(skipReader.TryAdvanceTo(10));
Assert.True(skipReader.TryAdvanceTo(4, advancePastDelimiter: false));
Assert.True(skipReader.TryRead(out byte value));
Assert.Equal(4, value);
Assert.True(skipReader.TryAdvanceToAny(new byte[] { 3, 12, 7 }, advancePastDelimiter: false));
Assert.True(skipReader.TryRead(out value));
Assert.Equal(7, value);
Assert.Equal(1, skipReader.AdvancePast(8));
Assert.True(skipReader.TryRead(out value));
Assert.Equal(9, value);
skipReader = new ByteBufferReader(bytes);
Assert.Equal(0, skipReader.AdvancePast(2));
Assert.Equal(3, skipReader.AdvancePastAny(new byte[] { 2, 3, 1 }));
Assert.True(skipReader.TryRead(out value));
Assert.Equal(4, value);
}
public void EmptyBytesReader()
{
var bytes = ReadOnlySequence <byte> .Empty;
var reader = new ByteBufferReader(bytes);
Assert.False(reader.TryReadTo(out ReadOnlySequence <byte> range, (byte)' '));
}
public void MultiSegmentBytesReaderNumbers()
{
ReadOnlySequence <byte> bytes = SequenceFactory.Create(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 },
new byte[] { 5, 6 },
new byte[] { 7, 8, 9, },
new byte[] { 0, 1, 2, 3 },
new byte[] { 4, 5 },
new byte[] { 6, 7, 8, 9 },
new byte[] { 0, 1, 2, 3 },
new byte[] { 4 },
});
ByteBufferReader reader = new ByteBufferReader(bytes);
Assert.True(reader.TryReadTo(out ReadOnlySequence <byte> bytesValue, 2));
Span <byte> span = bytesValue.ToArray();
Assert.Equal(0, span[0]);
Assert.Equal(1, span[1]);
Assert.True(reader.TryReadTo(out bytesValue, 5));
span = bytesValue.ToArray();
Assert.Equal(3, span[0]);
Assert.Equal(4, span[1]);
Assert.True(reader.TryReadTo(out bytesValue, new byte[] { 8, 8 }));
span = bytesValue.ToArray();
Assert.Equal(6, span[0]);
Assert.Equal(7, span[1]);
//Assert.True(SequenceMarshal.TryRead(ref reader, out int intValue));
Assert.True(reader.TryReadIntLE(out int intValue));
Assert.Equal(BitConverter.ToInt32(new byte[] { 0, 1, 0, 2 }), intValue);
Assert.True(reader.TryReadInt(out intValue));
Assert.Equal(BitConverter.ToInt32(new byte[] { 4, 3, 2, 1 }), intValue);
Assert.True(reader.TryReadLongLE(out long longValue));
Assert.Equal(BitConverter.ToInt64(new byte[] { 5, 6, 7, 8, 9, 0, 1, 2 }), longValue);
Assert.True(reader.TryReadLong(out longValue));
Assert.Equal(BitConverter.ToInt64(new byte[] { 0, 9, 8, 7, 6, 5, 4, 3 }), longValue);
Assert.True(reader.TryReadShortLE(out short shortValue));
Assert.Equal(BitConverter.ToInt16(new byte[] { 1, 2 }), shortValue);
Assert.True(reader.TryReadShort(out shortValue));
Assert.Equal(BitConverter.ToInt16(new byte[] { 4, 3 }), shortValue);
}
public static string DumpConditionalInt(ByteBufferReader reader)
{
var flags = reader[0].ReadByte();
var flagType = (FlagType)((flags & 0x0F) >> 0);
var opType = (OpType)((flags & 0xF0) >> 4);
switch (flagType)
{
case FlagType.Int:
{
switch (opType)
{
case OpType.StaticInt:
{
return(reader[1].ReadInt32().ToString(CultureInfo.InvariantCulture));
}
case OpType.Argument:
{
var value = reader[1].ReadInt32();
if (value == -1)
{
return("arg");
}
throw new NotImplementedException();
}
case OpType.Expression:
{
return("(" + DumpConditionalIntExpression(reader) + ")");
}
case OpType.Table:
{
return("plot.ints[" + reader[1].ReadInt32().ToString(CultureInfo.InvariantCulture) + "]");
}
default:
{
throw new NotImplementedException();
}
}
}
case FlagType.Float:
{
return(DumpConditionalFloat(reader));
}
default:
{
throw new NotImplementedException();
}
}
}
public void TryCopyTo_Empty()
{
var reader = new ByteBufferReader(ReadOnlySequence <byte> .Empty);
// Nothing to nothing is always possible
Assert.True(reader.TryCopyTo(Span <byte> .Empty));
// Nothing to something doesn't work
Assert.False(reader.TryCopyTo(new byte[1]));
}
bool Process(BlockType blockType, ByteBuffer block, IEventStoreObserver observer)
{
if ((blockType & BlockType.Compressed) != 0)
{
CompressionStrategy.Decompress(ref block);
}
var reader = new ByteBufferReader(block);
if ((blockType & BlockType.HasTypeDeclaration) != 0)
{
Mapping.LoadTypeDescriptors(reader);
}
var metadata = (blockType & BlockType.HasMetadata) != 0 ? Mapping.LoadObject(reader) : null;
uint eventCount;
if ((blockType & BlockType.HasOneEvent) != 0)
{
eventCount = 1;
}
else if ((blockType & BlockType.HasMoreEvents) != 0)
{
eventCount = reader.ReadVUInt32();
}
else
{
eventCount = 0;
}
var readEvents = observer.ObservedMetadata(metadata, eventCount);
if (!readEvents)
{
return(observer.ShouldStopReadingNextEvents());
}
var events = new object[eventCount];
var successfulEventCount = 0;
for (var i = 0; i < eventCount; i++)
{
var ev = Mapping.LoadObject(reader);
if (ev == null)
{
continue;
}
events[successfulEventCount] = ev;
successfulEventCount++;
}
if (eventCount != successfulEventCount)
{
Array.Resize(ref events, successfulEventCount);
}
observer.ObservedEvents(events);
return(observer.ShouldStopReadingNextEvents());
}
TValue ByteArrayToValue(ByteBuffer data)
{
var reader = new ByteBufferReader(data);
IReaderCtx ctx = null;
if (_valueHandler.NeedsCtx())
{
ctx = new DBReaderCtx(_tr, reader);
}
return(_valueReader(reader, ctx));
}
TKey ByteArrayToKey(ByteBuffer data)
{
var reader = new ByteBufferReader(data);
IReaderCtx ctx = null;
if (_keyHandler.NeedsCtx())
{
ctx = new DBReaderCtx(_tr, reader);
}
return(_keyReader(reader, ctx));
}
public void TryReadTo_Span_At_Segments_Boundary()
{
Span <byte> delimiter = new byte[] { 13, 10 }; // \r\n
BufferSegment <byte> segment = new BufferSegment <byte>(Text.Encoding.ASCII.GetBytes("Hello\r"));
segment.Append(Text.Encoding.ASCII.GetBytes("\nWorld")); // add next segment
ReadOnlySequence <byte> inputSeq = new ReadOnlySequence <byte>(segment, 0, segment, 6); // span only the first segment!
ByteBufferReader sr = new ByteBufferReader(inputSeq);
bool r = sr.TryReadTo(out _, delimiter);
Assert.False(r);
}
public void TryReadTo_NotFound_Sequence(bool advancePastDelimiter)
{
ReadOnlySequence <byte> bytes = SequenceFactory.Create(new byte[][] {
new byte[] { 1 },
new byte[] { 2, 3, 255 }
});
ByteBufferReader reader = new ByteBufferReader(bytes);
reader.Advance(4);
Assert.False(reader.TryReadTo(out ReadOnlySequence <byte> span, 255, 0, advancePastDelimiter));
}
void CanSerializeSimpleValue(object value)
{
var writer = new ByteBufferWriter();
var storedDescriptorCtx = _mapping.StoreNewDescriptors(writer, value);
storedDescriptorCtx.FinishNewDescriptors(writer);
storedDescriptorCtx.StoreObject(writer, value);
storedDescriptorCtx.CommitNewDescriptors();
var reader = new ByteBufferReader(writer.Data);
var obj = _mapping.LoadObject(reader);
Assert.Equal(value, obj);
}
public void CanSerializeInt()
{
var writer = new ByteBufferWriter();
var storedDescriptorCtx = _mapping.StoreNewDescriptors(writer, 12345);
storedDescriptorCtx.FinishNewDescriptors(writer);
storedDescriptorCtx.StoreObject(writer, 12345);
storedDescriptorCtx.CommitNewDescriptors();
var reader = new ByteBufferReader(writer.Data);
var obj = _mapping.LoadObject(reader);
Assert.Equal(12345, obj);
}
public void Basics()
{
var buffer = Unpooled.Buffer(1024);
var writer = new ByteBufferWriter(buffer);
writer.WriteByte(1);
writer.WriteShort(12);
writer.WriteShortLE(21);
writer.WriteMedium(13);
writer.WriteMediumLE(31);
writer.WriteInt(14);
writer.WriteIntLE(41);
writer.WriteLong(15);
writer.WriteLongLE(51);
writer.WriteDecimal(168.86m);
writer.WriteDecimalLE(188.88m);
writer.Flush();
var reader = new ByteBufferReader(buffer);
reader.TryRead(out byte b);
Assert.Equal(1, b);
reader.TryReadShort(out var sV);
Assert.Equal(12, sV);
reader.TryReadShortLE(out sV);
Assert.Equal(21, sV);
reader.TryReadMedium(out var iV);
Assert.Equal(13, iV);
reader.TryReadMediumLE(out iV);
Assert.Equal(31, iV);
reader.TryReadInt(out iV);
Assert.Equal(14, iV);
reader.TryReadIntLE(out iV);
Assert.Equal(41, iV);
reader.TryReadLong(out var lV);
Assert.Equal(15, lV);
reader.TryReadLongLE(out lV);
Assert.Equal(51, lV);
reader.TryReadDecimal(out var mV);
Assert.Equal(168.86m, mV);
reader.TryReadDecimalLE(out mV);
Assert.Equal(188.88m, mV);
}
public void TakeReturnsByteAndMoves()
{
var reader = new ByteBufferReader(Factory.CreateWithContent(GetInputData(2)));
Assert.Equal(0, reader.CurrentSpanIndex);
Assert.Equal(InputData[0], reader.CurrentSpan[reader.CurrentSpanIndex]);
Assert.True(reader.TryRead(out byte value));
Assert.Equal(InputData[0], value);
Assert.Equal(1, reader.CurrentSpanIndex);
Assert.Equal(InputData[1], reader.CurrentSpan[reader.CurrentSpanIndex]);
Assert.True(reader.TryRead(out value));
Assert.Equal(InputData[1], value);
Assert.False(reader.TryRead(out value));
Assert.Equal(default, value);
public void TryReadTo_Sequence(bool advancePastDelimiter, bool useEscapeOverload)
{
ReadOnlySequence <byte> bytes = SequenceFactory.Create(new byte[][] {
new byte[] { 0 },
new byte[] { 1, 2 },
new byte[] { },
new byte[] { 3, 4, 5, 6 }
});
ByteBufferReader reader = new ByteBufferReader(bytes);
// Read to 0-5
for (byte i = 0; i < bytes.Length - 1; i++)
{
ByteBufferReader copy = reader;
// Can read to the first integer (0-5)
Assert.True(
useEscapeOverload
? copy.TryReadTo(out ReadOnlySequence <byte> sequence, i, 255, advancePastDelimiter)
: copy.TryReadTo(out sequence, i, advancePastDelimiter));
// Should never have a null Position object
Assert.NotNull(copy.Position.GetObject());
ReadOnlySequence <byte> .Enumerator enumerator = sequence.GetEnumerator();
while (enumerator.MoveNext())
{
;
}
// Should be able to read to final 6
Assert.True(
useEscapeOverload
? copy.TryReadTo(out sequence, 6, 255, advancePastDelimiter)
: copy.TryReadTo(out sequence, 6, advancePastDelimiter));
Assert.NotNull(copy.Position.GetObject());
enumerator = sequence.GetEnumerator();
while (enumerator.MoveNext())
{
;
}
// If we didn't advance, we should still be able to read to 6
Assert.Equal(!advancePastDelimiter,
useEscapeOverload
? copy.TryReadTo(out sequence, 6, 255, advancePastDelimiter)
: copy.TryReadTo(out sequence, 6, advancePastDelimiter));
}
}
public void AdvanceSingleBufferSkipsBytes()
{
var reader = new ByteBufferReader(BufferUtilities.CreateBuffer(GetInputData(5)));
reader.Advance(2);
Assert.Equal(2, reader.CurrentSpanIndex);
Assert.Equal(InputData[2], reader.CurrentSpan[reader.CurrentSpanIndex]);
Assert.True(reader.TryPeek(out byte value));
Assert.Equal(InputData[2], value);
reader.Advance(2);
Assert.True(reader.TryPeek(out value));
Assert.Equal(InputData[4], value);
Assert.Equal(4, reader.CurrentSpanIndex);
Assert.Equal(InputData[4], reader.CurrentSpan[reader.CurrentSpanIndex]);
}
ByteBuffer WriteSecondaryKeyKey(uint secondaryKeyIndex, ByteBuffer keyBytes, ByteBuffer valueBytes)
{
var keyWriter = new ByteBufferWriter();
keyWriter.WriteVUInt32(_relationInfo.Id);
keyWriter.WriteVUInt32(secondaryKeyIndex);
var valueReader = new ByteBufferReader(valueBytes);
var version = valueReader.ReadVUInt32();
var keySaver = _relationInfo.GetPKValToSKMerger(version, secondaryKeyIndex);
keySaver(_transaction, keyWriter, new ByteBufferReader(keyBytes), new ByteBufferReader(valueBytes), _relationInfo.DefaultClientObject);
return(keyWriter.Data);
}
public void SingleSegmentBytesReader()
{
byte[] buffer = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var bytes = new ReadOnlySequence <byte>(buffer);
var reader = new ByteBufferReader(bytes);
Assert.True(reader.TryReadTo(out ReadOnlySequence <byte> ab, 3));
Assert.True(ab.First.Span.SequenceEqual(new byte[] { 1, 2 }));
Assert.True(reader.TryReadTo(out ReadOnlySequence <byte> cd, 6));
Assert.True(cd.First.Span.SequenceEqual(new byte[] { 4, 5 }));
Assert.True(reader.TryReadTo(out ReadOnlySequence <byte> ef, new byte[] { 8, 9 }));
Assert.True(ef.First.Span.SequenceEqual(new byte[] { 7 }));
}
public void IsNext_Empty(bool advancePast)
{
var reader = new ByteBufferReader(ReadOnlySequence <byte> .Empty);
Assert.False(reader.IsNext((byte)'Z', advancePast));
Assert.Equal(0, reader.Consumed);
// Nothing is always next
Assert.True(reader.IsNext(ReadOnlySpan <byte> .Empty, advancePast));
Assert.Equal(0, reader.Consumed);
// Something isn't
Assert.False(reader.IsNext(new byte[] { (byte)'\0' }, advancePast));
Assert.Equal(0, reader.Consumed);
}
public SortNormalBlock(ByteBufferReader reader)
{
reader.FastForward(sizeof(int));
size = reader.ReadInt();
planeNormal = reader.ReadVector3();
planePoint = reader.ReadVector3();
reserved = reader.ReadInt();
frontOffset = reader.ReadInt();
backOffset = reader.ReadInt();
preListOffset = reader.ReadInt();
postListOffset = reader.ReadInt();
onlineOffset = reader.ReadInt();
boundingBoxMin = reader.ReadVector3();
boundingBoxMax = reader.ReadVector3();
}
void IterateFields(ByteBufferReader reader, IEnumerable <TableFieldInfo> fields, HashSet <int> knownInlineRefs)
{
foreach (var fi in fields)
{
if (_visitor == null || _visitor.StartField(fi.Name))
{
IterateHandler(reader, fi.Handler, false, knownInlineRefs);
_visitor?.EndField();
}
else
{
IterateHandler(reader, fi.Handler, true, knownInlineRefs);
}
}
}
public void RewindEmptyFirstSpan()
{
// This is to hit the "if (memory.Length == 0)" branch in ResetReader.
ReadOnlySequence <byte> bytes = SequenceFactory.Create(new byte[][] {
new byte[0],
new byte[] { 1, 2 },
new byte[] { 3, 4 }
});
var reader = new ByteBufferReader(bytes);
reader.Advance(3);
Assert.True(reader.IsNext(4));
reader.Rewind(2);
Assert.Equal(new byte[] { 1, 2 }, reader.CurrentSpan.ToArray());
}
