mirror of
https://github.com/google/flatbuffers.git
synced 2026-06-02 04:04:19 +00:00
1a7495a6dd
* [C#] Add GetBytes methods for fixed arrays I wanted to direct access to fixed array bytes. I made some changes to the idl generator to create GetBytes functions following the same naming conventions used for vectors of scalar types. There was not a 'Length' field present to bound the existing index accessor so I added that too. + Add generic GetBytes for fixed length arrays of scalar types + Implement conditional compilation for ENABLE_SPAN_T: - ENABLE_SPAN_T: Returns `Span<T>` using `MemoryMarshal.Cast<byte, T>()` as needed. - Else: Returns `ArraySegment<byte>?` for raw byte access + Added tests reusing arrays_test.fbs definitions + Added const int Length field to support existing index based accessors * [C#] Sync generated code for after adding GetBytes methods for fixed arrays --------- Co-authored-by: Björn Harrtell <bjornharrtell@users.noreply.github.com>
250 lines
11 KiB
C#
250 lines
11 KiB
C#
/*
|
|
* Copyright 2025 Google Inc. All rights reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
using System;
|
|
using System.Linq;
|
|
using MyGame.Example;
|
|
|
|
namespace Google.FlatBuffers.Test
|
|
{
|
|
[FlatBuffersTestClass]
|
|
public class FlatBuffersFixedLengthArrayTests
|
|
{
|
|
[FlatBuffersTestMethod]
|
|
public void FixedLengthArray_LengthConstantsMatchSchema_ReturnTrue()
|
|
{
|
|
const int nestedALength = NestedStruct.ALength;
|
|
const int nestedCLength = NestedStruct.CLength;
|
|
const int nestedDLength = NestedStruct.DLength;
|
|
const int arrayBLength = ArrayStruct.BLength;
|
|
const int arrayFLength = ArrayStruct.FLength;
|
|
|
|
Assert.AreEqual(2, nestedALength);
|
|
Assert.AreEqual(2, nestedCLength);
|
|
Assert.AreEqual(2, nestedDLength);
|
|
Assert.AreEqual(15, arrayBLength);
|
|
Assert.AreEqual(2, arrayFLength);
|
|
}
|
|
|
|
#if ENABLE_SPAN_T
|
|
[FlatBuffersTestMethod]
|
|
public void FixedLengthArray_GetBytesSpanLengthIsCorrect_ReturnTrue()
|
|
{
|
|
var builder = new FlatBufferBuilder(1024);
|
|
var ints = new int[] { 1, 2 };
|
|
var enumB = TestEnum.A;
|
|
var enums = new TestEnum[] { TestEnum.B, TestEnum.C };
|
|
var longs = new long[] { 10L, 20L };
|
|
|
|
var structOffset = NestedStruct.CreateNestedStruct(builder, ints, enumB, enums, longs);
|
|
builder.Finish(structOffset.Value);
|
|
|
|
var bb = builder.DataBuffer;
|
|
var nestedStruct = new NestedStruct();
|
|
nestedStruct.__assign(bb.Length - builder.Offset, bb);
|
|
|
|
Span<int> intSpan = nestedStruct.GetABytes();
|
|
Span<TestEnum> enumSpan = nestedStruct.GetCBytes();
|
|
Span<long> longSpan = nestedStruct.GetDBytes();
|
|
|
|
Assert.AreEqual(intSpan.Length, NestedStruct.ALength);
|
|
Assert.AreEqual(enumSpan.Length, NestedStruct.CLength);
|
|
Assert.AreEqual(longSpan.Length, NestedStruct.DLength);
|
|
}
|
|
#endif
|
|
|
|
#if !ENABLE_SPAN_T
|
|
[FlatBuffersTestMethod]
|
|
public void FixedLengthArray_GetBytesArraySegmentLengthIsCorrect_ReturnTrue()
|
|
{
|
|
var builder = new FlatBufferBuilder(1024);
|
|
var ints = new int[] { 1, 2 };
|
|
var enumB = TestEnum.A;
|
|
var enums = new TestEnum[] { TestEnum.B, TestEnum.C };
|
|
var longs = new long[] { 10L, 20L };
|
|
|
|
var structOffset = NestedStruct.CreateNestedStruct(builder, ints, enumB, enums, longs);
|
|
builder.Finish(structOffset.Value);
|
|
|
|
var buffer = builder.DataBuffer;
|
|
var nestedStruct = new NestedStruct();
|
|
nestedStruct.__assign(buffer.Length - builder.Offset, buffer);
|
|
|
|
Assert.IsTrue(nestedStruct.GetABytes().HasValue);
|
|
Assert.IsTrue(nestedStruct.GetCBytes().HasValue);
|
|
Assert.IsTrue(nestedStruct.GetDBytes().HasValue);
|
|
|
|
ArraySegment<byte> intSegment = nestedStruct.GetABytes().Value;
|
|
ArraySegment<byte> enumSegment = nestedStruct.GetCBytes().Value;
|
|
ArraySegment<byte> longSegment = nestedStruct.GetDBytes().Value;
|
|
|
|
Assert.AreEqual(intSegment.Count, NestedStruct.ALength * sizeof(int));
|
|
Assert.AreEqual(enumSegment.Count, NestedStruct.CLength * sizeof(sbyte));
|
|
Assert.AreEqual(longSegment.Count, NestedStruct.DLength * sizeof(long));
|
|
}
|
|
#endif
|
|
|
|
#if ENABLE_SPAN_T
|
|
[FlatBuffersTestMethod]
|
|
public void FixedLengthArray_GetBytesSpanEquality_ReturnTrue()
|
|
{
|
|
var builder = new FlatBufferBuilder(1024);
|
|
|
|
var floatA = 3.14f;
|
|
var intArray = Enumerable.Range(1, 15).ToArray();
|
|
var byteC = (sbyte)42;
|
|
var intE = 999;
|
|
var longArray = new long[] { 5000L, 6000L };
|
|
|
|
var nestedInts = new int[2, 2] { { 10, 20 }, { 30, 40 } };
|
|
var nestedEnumB = new TestEnum[] { TestEnum.A, TestEnum.B };
|
|
var nestedEnums = new TestEnum[2, 2] { { TestEnum.A, TestEnum.B }, { TestEnum.C, TestEnum.A } };
|
|
var nestedLongs = new long[2, 2] { { 100L, 200L }, { 300L, 400L } };
|
|
|
|
var structOffset = ArrayStruct.CreateArrayStruct(builder, floatA, intArray, byteC,
|
|
nestedInts, nestedEnumB, nestedEnums, nestedLongs, intE, longArray);
|
|
|
|
ArrayTable.StartArrayTable(builder);
|
|
ArrayTable.AddA(builder, structOffset);
|
|
var rootTable = ArrayTable.EndArrayTable(builder);
|
|
builder.Finish(rootTable.Value);
|
|
|
|
var finishedBytes = builder.SizedByteArray();
|
|
ByteBuffer bb = new ByteBuffer(finishedBytes);
|
|
ArrayTable arrayTable = ArrayTable.GetRootAsArrayTable(bb);
|
|
ArrayStruct arrayStruct = arrayTable.A.Value;
|
|
|
|
Assert.AreEqual(byteC, arrayStruct.C);
|
|
Assert.AreEqual(intE, arrayStruct.E);
|
|
|
|
Assert.IsTrue(arrayStruct.GetBBytes().SequenceEqual(intArray));
|
|
Assert.IsTrue(arrayStruct.GetFBytes().SequenceEqual(longArray));
|
|
|
|
// Test nested struct arrays
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
var nestedStruct = arrayStruct.D(i);
|
|
|
|
var nestedIntSpan = nestedStruct.GetABytes();
|
|
var expectedNestedInts = new int[] { nestedInts[i, 0], nestedInts[i, 1] };
|
|
Assert.IsTrue(nestedIntSpan.SequenceEqual(expectedNestedInts));
|
|
|
|
Assert.AreEqual(nestedEnumB[i], nestedStruct.B);
|
|
|
|
var nestedEnumSpan = nestedStruct.GetCBytes();
|
|
var expectedNestedEnums = new TestEnum[] { nestedEnums[i, 0], nestedEnums[i, 1] };
|
|
Assert.IsTrue(nestedEnumSpan.SequenceEqual(expectedNestedEnums));
|
|
|
|
var nestedLongSpan = nestedStruct.GetDBytes();
|
|
var expectedNestedLongs = new long[] { nestedLongs[i, 0], nestedLongs[i, 1] };
|
|
Assert.IsTrue(nestedLongSpan.SequenceEqual(expectedNestedLongs));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if !ENABLE_SPAN_T
|
|
[FlatBuffersTestMethod]
|
|
public void FixedLengthArray_GetBytesArraySegmentEquality_ReturnTrue()
|
|
{
|
|
var builder = new FlatBufferBuilder(1024);
|
|
|
|
var floatA = 3.14f;
|
|
var intArray = Enumerable.Range(1, 15).ToArray();
|
|
var byteC = (sbyte)42;
|
|
var intE = 999;
|
|
var longArray = new long[] { 5000L, 6000L };
|
|
|
|
var nestedInts = new int[2, 2] { { 10, 20 }, { 30, 40 } };
|
|
var nestedEnumB = new TestEnum[] { TestEnum.A, TestEnum.B };
|
|
var nestedEnums = new TestEnum[2, 2] { { TestEnum.A, TestEnum.B }, { TestEnum.C, TestEnum.A } };
|
|
var nestedLongs = new long[2, 2] { { 100L, 200L }, { 300L, 400L } };
|
|
|
|
var structOffset = ArrayStruct.CreateArrayStruct(builder, floatA, intArray, byteC,
|
|
nestedInts, nestedEnumB, nestedEnums, nestedLongs, intE, longArray);
|
|
|
|
ArrayTable.StartArrayTable(builder);
|
|
ArrayTable.AddA(builder, structOffset);
|
|
var rootTable = ArrayTable.EndArrayTable(builder);
|
|
builder.Finish(rootTable.Value);
|
|
|
|
var finishedBytes = builder.SizedByteArray();
|
|
ByteBuffer bb = new ByteBuffer(finishedBytes);
|
|
ArrayTable arrayTable = ArrayTable.GetRootAsArrayTable(bb);
|
|
ArrayStruct arrayStruct = arrayTable.A.Value;
|
|
|
|
// Test that we can read basic scalars correctly
|
|
Assert.AreEqual(byteC, arrayStruct.C);
|
|
Assert.AreEqual(intE, arrayStruct.E);
|
|
|
|
Assert.IsTrue(arrayStruct.GetBBytes().HasValue);
|
|
var intSegment = arrayStruct.GetBBytes().Value;
|
|
for (int i = 0, offset = 0; i < intArray.Length; i++, offset += sizeof(int))
|
|
{
|
|
var segmentValue = BitConverter.ToInt32(intSegment.Array,
|
|
intSegment.Offset + offset);
|
|
Assert.AreEqual(intArray[i], segmentValue);
|
|
}
|
|
|
|
Assert.IsTrue(arrayStruct.GetFBytes().HasValue);
|
|
var longSegment = arrayStruct.GetFBytes().Value;
|
|
for (int i = 0, offset = 0; i < longArray.Length; i++, offset += sizeof(long))
|
|
{
|
|
var segmentValue = BitConverter.ToInt64(longSegment.Array,
|
|
longSegment.Offset + offset);
|
|
Assert.AreEqual(longArray[i], segmentValue);
|
|
}
|
|
|
|
// Test nested struct arrays
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
var nestedStruct = arrayStruct.D(i);
|
|
|
|
Assert.IsTrue(nestedStruct.GetABytes().HasValue);
|
|
var nestedIntSegment = nestedStruct.GetABytes().Value;
|
|
var expectedNestedInts = new int[] { nestedInts[i, 0], nestedInts[i, 1] };
|
|
for (int ii = 0, offset = 0; ii < NestedStruct.ALength; ii++, offset += sizeof(int))
|
|
{
|
|
var segmentValue = BitConverter.ToInt32(nestedIntSegment.Array,
|
|
nestedIntSegment.Offset + offset);
|
|
Assert.AreEqual(expectedNestedInts[ii], segmentValue);
|
|
}
|
|
|
|
Assert.AreEqual(nestedEnumB[i], nestedStruct.B);
|
|
|
|
Assert.IsTrue(nestedStruct.GetCBytes().HasValue);
|
|
var nestedEnumSegment = nestedStruct.GetCBytes().Value;
|
|
var expectedNestedEnums = new TestEnum[] { nestedEnums[i, 0], nestedEnums[i, 1] };
|
|
for (int ii = 0, offset = 0; ii < NestedStruct.CLength; ii++, offset += sizeof(sbyte))
|
|
{
|
|
var segmentValue = (TestEnum)nestedEnumSegment.Array[nestedEnumSegment.Offset + offset];
|
|
Assert.AreEqual(expectedNestedEnums[ii], segmentValue);
|
|
}
|
|
|
|
Assert.IsTrue(nestedStruct.GetDBytes().HasValue);
|
|
var nestedLongSegment = nestedStruct.GetDBytes().Value;
|
|
var expectedNestedLongs = new long[] { nestedLongs[i, 0], nestedLongs[i, 1] };
|
|
for (int ii = 0, offset = 0; ii < NestedStruct.DLength; ii++, offset += sizeof(long))
|
|
{
|
|
var segmentValue = BitConverter.ToInt64(nestedLongSegment.Array,
|
|
nestedLongSegment.Offset + offset);
|
|
Assert.AreEqual(expectedNestedLongs[ii], segmentValue);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|