From c9651b7420f9a42f45b19aa4fd24aa0204b9c918 Mon Sep 17 00:00:00 2001 From: Jamie-Jameson <101665489+Jamie-Jameson@users.noreply.github.com> Date: Fri, 1 Apr 2022 22:35:07 +0200 Subject: [PATCH] Add overloads for C# ByteBuffer/FlatBufferBuilder to allow adding vector blocks from ArraySegments or IntPtr (#7193) * Add overloads to Add/Put for ArraySegment and IntPtr In order to allow using code to reduce memory allocations, add overloads to ByteBuffer's and FlatBuffersBuilder's Put/Add methods that take ArraySegment or IntPtr respectively. Also, adaptions to the c# code generator in flatc to emit corresponding CreateVectorBlock() overloads * Add missing files generated with generate_code.py The previous commit changed the C# code generate, but didn't contain the updated generated test files. * Incorporate review findings (1) Adhere to 80 characters limit. (2) In FlatBufferBuilder.Add(IntPtr,int), move zero length check topmost and add sanity check against negative input --- net/FlatBuffers/ByteBuffer.cs | 100 ++++++++++- net/FlatBuffers/FlatBufferBuilder.cs | 82 ++++++++- src/idl_gen_csharp.cpp | 20 +++ tests/FlatBuffers.Test/ByteBufferTests.cs | 127 ++++++++++++-- .../FlatBufferBuilderTests.cs | 165 ++++++++++++++++++ .../FlatBuffers.Core.Test.csproj | 8 + .../FlatBuffers.Test/FlatBuffers.Test.csproj | 2 + tests/MyGame/Example/Monster.cs | 34 ++++ tests/MyGame/Example/TypeAliases.cs | 4 + tests/MyGame/MonsterExtra.cs | 4 + tests/union_vector/Movie.cs | 4 + 11 files changed, 536 insertions(+), 14 deletions(-) diff --git a/net/FlatBuffers/ByteBuffer.cs b/net/FlatBuffers/ByteBuffer.cs index 6e0fe35bb..15d77879b 100644 --- a/net/FlatBuffers/ByteBuffer.cs +++ b/net/FlatBuffers/ByteBuffer.cs @@ -225,6 +225,18 @@ namespace FlatBuffers return SizeOf() * x.Length; } + /// + /// Get the wire-size (in bytes) of an typed array segment, taking only the + /// range specified by into account. + /// + /// The type of the array + /// The array segment to get the size of + /// The number of bytes the array segment takes on wire + public static int ArraySize(ArraySegment x) + { + return SizeOf() * x.Count; + } + #if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1) public static int ArraySize(Span x) { @@ -869,7 +881,30 @@ namespace FlatBuffers throw new ArgumentNullException("Cannot put a null array"); } - if (x.Length == 0) + return Put(offset, new ArraySegment(x)); + } + + /// + /// Copies an array segment of type T into this buffer, ending at the + /// given offset into this buffer. The starting offset is calculated + /// based on the count of the array segment and is the value returned. + /// + /// The type of the input data (must be a struct) + /// + /// The offset into this buffer where the copy + /// will end + /// The array segment to copy data from + /// The 'start' location of this buffer now, after the copy + /// completed + public int Put(int offset, ArraySegment x) + where T : struct + { + if (x.Equals(default(ArraySegment))) + { + throw new ArgumentNullException("Cannot put a uninitialized array segment"); + } + + if (x.Count == 0) { throw new ArgumentException("Cannot put an empty array"); } @@ -889,7 +924,68 @@ namespace FlatBuffers #if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1) MemoryMarshal.Cast(x).CopyTo(_buffer.Span.Slice(offset, numBytes)); #else - Buffer.BlockCopy(x, 0, _buffer.Buffer, offset, numBytes); + var srcOffset = ByteBuffer.SizeOf() * x.Offset; + Buffer.BlockCopy(x.Array, srcOffset, _buffer.Buffer, offset, numBytes); +#endif + } + else + { + throw new NotImplementedException("Big Endian Support not implemented yet " + + "for putting typed arrays"); + // if we are BE, we have to swap each element by itself + //for(int i = x.Length - 1; i >= 0; i--) + //{ + // todo: low priority, but need to genericize the Put() functions + //} + } + return offset; + } + + /// + /// Copies an array segment of type T into this buffer, ending at the + /// given offset into this buffer. The starting offset is calculated + /// based on the count of the array segment and is the value returned. + /// + /// The type of the input data (must be a struct) + /// + /// The offset into this buffer where the copy + /// will end + /// The pointer to copy data from + /// The number of bytes to copy + /// The 'start' location of this buffer now, after the copy + /// completed + public int Put(int offset, IntPtr ptr, int sizeInBytes) + where T : struct + { + if (ptr == IntPtr.Zero) + { + throw new ArgumentNullException("Cannot add a null pointer"); + } + + if(sizeInBytes <= 0) + { + throw new ArgumentException("Cannot put an empty array"); + } + + if (!IsSupportedType()) + { + throw new ArgumentException("Cannot put an array of type " + + typeof(T) + " into this buffer"); + } + + if (BitConverter.IsLittleEndian) + { + offset -= sizeInBytes; + AssertOffsetAndLength(offset, sizeInBytes); + // if we are LE, just do a block copy +#if ENABLE_SPAN_T && UNSAFE_BYTEBUFFER + unsafe + { + var span = new Span(ptr.ToPointer(), sizeInBytes); + span.CopyTo(_buffer.Span.Slice(offset, sizeInBytes)); + } +#else + Marshal.Copy(ptr, _buffer.Buffer, offset, sizeInBytes); #endif } else diff --git a/net/FlatBuffers/FlatBufferBuilder.cs b/net/FlatBuffers/FlatBufferBuilder.cs index c72b6248a..252c7cd1b 100644 --- a/net/FlatBuffers/FlatBufferBuilder.cs +++ b/net/FlatBuffers/FlatBufferBuilder.cs @@ -210,6 +210,31 @@ namespace FlatBuffers _space = _bb.Put(_space, x); } + /// + /// Puts an array of type T into this builder at the + /// current offset + /// + /// The type of the input data + /// The array segment to copy data from + public void Put(ArraySegment x) + where T : struct + { + _space = _bb.Put(_space, x); + } + + /// + /// Puts data of type T into this builder at the + /// current offset + /// + /// The type of the input data + /// The pointer to copy data from + /// The length of the data in bytes + public void Put(IntPtr ptr, int sizeInBytes) + where T : struct + { + _space = _bb.Put(_space, ptr, sizeInBytes); + } + #if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1) /// /// Puts a span of type T into this builder at the @@ -297,13 +322,24 @@ namespace FlatBuffers /// The array to copy data from public void Add(T[] x) where T : struct + { + Add(new ArraySegment(x)); + } + + /// + /// Add an array of type T to the buffer (aligns the data and grows if necessary). + /// + /// The type of the input data + /// The array segment to copy data from + public void Add(ArraySegment x) + where T : struct { if (x == null) { throw new ArgumentNullException("Cannot add a null array"); } - if( x.Length == 0) + if( x.Count == 0) { // don't do anything if the array is empty return; @@ -317,10 +353,52 @@ namespace FlatBuffers int size = ByteBuffer.SizeOf(); // Need to prep on size (for data alignment) and then we pass the // rest of the length (minus 1) as additional bytes - Prep(size, size * (x.Length - 1)); + Prep(size, size * (x.Count - 1)); Put(x); } + /// + /// Adds the data of type T pointed to by the given pointer to the buffer (aligns the data and grows if necessary). + /// + /// The type of the input data + /// The pointer to copy data from + /// The data size in bytes + public void Add(IntPtr ptr, int sizeInBytes) + where T : struct + { + if(sizeInBytes == 0) + { + // don't do anything if the array is empty + return; + } + + if (ptr == IntPtr.Zero) + { + throw new ArgumentNullException("Cannot add a null pointer"); + } + + if(sizeInBytes < 0) + { + throw new ArgumentOutOfRangeException("sizeInBytes", "sizeInBytes cannot be negative"); + } + + if(!ByteBuffer.IsSupportedType()) + { + throw new ArgumentException("Cannot add this Type array to the builder"); + } + + int size = ByteBuffer.SizeOf(); + if((sizeInBytes % size) != 0) + { + throw new ArgumentException("The given size in bytes " + sizeInBytes + " doesn't match the element size of T ( " + size + ")", "sizeInBytes"); + } + + // Need to prep on size (for data alignment) and then we pass the + // rest of the length (minus 1) as additional bytes + Prep(size, sizeInBytes - size); + Put(ptr, sizeInBytes); + } + #if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1) /// /// Add a span of type T to the buffer (aligns the data and grows if necessary). diff --git a/src/idl_gen_csharp.cpp b/src/idl_gen_csharp.cpp index bbb3ec3a9..b530f4f84 100644 --- a/src/idl_gen_csharp.cpp +++ b/src/idl_gen_csharp.cpp @@ -1240,6 +1240,7 @@ class CSharpGenerator : public BaseGenerator { code += "); return "; code += "builder.EndVector(); }\n"; + // add Create...VectorBlock() overloads for T[], ArraySegment and IntPtr code += " public static VectorOffset "; code += "Create"; code += Name(field); @@ -1250,6 +1251,25 @@ class CSharpGenerator : public BaseGenerator { code += ", data.Length, "; code += NumToString(alignment); code += "); builder.Add(data); return builder.EndVector(); }\n"; + + code += " public static VectorOffset "; + code += "Create"; + code += Name(field); + code += "VectorBlock(FlatBufferBuilder builder, "; + code += "ArraySegment<" + GenTypeBasic(vector_type) + "> data) "; + code += "{ builder.StartVector("; + code += NumToString(elem_size); + code += ", data.Count, "; + code += NumToString(alignment); + code += "); builder.Add(data); return builder.EndVector(); }\n"; + + code += " public static VectorOffset "; + code += "Create"; + code += Name(field); + code += "VectorBlock(FlatBufferBuilder builder, "; + code += "IntPtr dataPtr, int sizeInBytes) "; + code += "{ builder.StartVector(1, sizeInBytes, 1); "; + code += "builder.Add<" + GenTypeBasic(vector_type) + ">(dataPtr, sizeInBytes); return builder.EndVector(); }\n"; } // Generate a method to start a vector, data to be added manually // after. diff --git a/tests/FlatBuffers.Test/ByteBufferTests.cs b/tests/FlatBuffers.Test/ByteBufferTests.cs index 98e917c11..2507073b9 100644 --- a/tests/FlatBuffers.Test/ByteBufferTests.cs +++ b/tests/FlatBuffers.Test/ByteBufferTests.cs @@ -15,6 +15,7 @@ */ using System; +using System.Runtime.InteropServices; namespace FlatBuffers.Test { @@ -408,6 +409,60 @@ namespace FlatBuffers.Test Assert.ArrayEqual(data, bbArray); } + public void ByteBuffer_Put_ArraySegment_Helper(ArraySegment data, int typeSize) + where T : struct + { + // Create the Byte Buffer + var uut = new ByteBuffer(1024); + + // Put the data into the buffer and make sure the offset is + // calculated correctly + int nOffset = uut.Put(1024, data); + Assert.AreEqual(1024 - typeSize * data.Count, nOffset); + + // Get the full array back out and ensure they are equivalent + var bbArray = uut.ToArray(nOffset, data.Count); + Assert.ArrayEqual(data.ToArray(), bbArray); + } + + public unsafe void ByteBuffer_Put_IntPtr_Helper(T[] data, int typeSize) + where T : struct + { + GCHandle handle = GCHandle.Alloc(data, GCHandleType.Pinned); + try + { + var dataPtr = handle.AddrOfPinnedObject(); + var sizeInBytes = data.Length * typeSize; + + // Create the Byte Buffer + var uut = new ByteBuffer(1024); + + // Put the data into the buffer and make sure the offset is + // calculated correctly + int nOffset = uut.Put(1024, dataPtr, sizeInBytes); + Assert.AreEqual(1024 - sizeInBytes, nOffset); + + // Get the full array back out and ensure they are equivalent + var bbArray = uut.ToArray(nOffset, data.Length); + Assert.ArrayEqual(data, bbArray); + } + finally + { + handle.Free(); + } + } + + public void ByteBuffer_Put_ArrayTypes_Helper(T[] data, int typeSize) + where T : struct + { + ByteBuffer_Put_Array_Helper(data, typeSize); + + var arraySegment = CreateArraySegment(data); + ByteBuffer_Put_ArraySegment_Helper(arraySegment, typeSize); + + ByteBuffer_Put_IntPtr_Helper(data, typeSize); + } + [FlatBuffersTestMethod] public void ByteBuffer_Put_Array_Float() { @@ -425,7 +480,7 @@ namespace FlatBuffers.Test data[7] = 15.9994F; data[8] = 18.9984F; - ByteBuffer_Put_Array_Helper(data, sizeof(float)); + ByteBuffer_Put_ArrayTypes_Helper(data, sizeof(float)); } [FlatBuffersTestMethod] @@ -445,7 +500,7 @@ namespace FlatBuffers.Test data[7] = 15.9994; data[8] = 18.9984; - ByteBuffer_Put_Array_Helper(data, sizeof(double)); + ByteBuffer_Put_ArrayTypes_Helper(data, sizeof(double)); } [FlatBuffersTestMethod] @@ -465,7 +520,7 @@ namespace FlatBuffers.Test data[7] = 15; data[8] = 18; - ByteBuffer_Put_Array_Helper(data, sizeof(int)); + ByteBuffer_Put_ArrayTypes_Helper(data, sizeof(int)); } @@ -486,7 +541,7 @@ namespace FlatBuffers.Test data[7] = 15; data[8] = 18; - ByteBuffer_Put_Array_Helper(data, sizeof(uint)); + ByteBuffer_Put_ArrayTypes_Helper(data, sizeof(uint)); } [FlatBuffersTestMethod] @@ -506,7 +561,7 @@ namespace FlatBuffers.Test data[7] = true; data[8] = false; - ByteBuffer_Put_Array_Helper(data, sizeof(bool)); + ByteBuffer_Put_ArrayTypes_Helper(data, sizeof(bool)); } [FlatBuffersTestMethod] @@ -526,7 +581,7 @@ namespace FlatBuffers.Test data[7] = 15; data[8] = 18; - ByteBuffer_Put_Array_Helper(data, sizeof(long)); + ByteBuffer_Put_ArrayTypes_Helper(data, sizeof(long)); } [FlatBuffersTestMethod] @@ -546,7 +601,7 @@ namespace FlatBuffers.Test data[7] = 15; data[8] = 18; - ByteBuffer_Put_Array_Helper(data, sizeof(byte)); + ByteBuffer_Put_ArrayTypes_Helper(data, sizeof(byte)); } [FlatBuffersTestMethod] @@ -566,7 +621,16 @@ namespace FlatBuffers.Test data[7] = 15; data[8] = 18; - ByteBuffer_Put_Array_Helper(data, sizeof(sbyte)); + ByteBuffer_Put_ArrayTypes_Helper(data, sizeof(sbyte)); + } + + private static ArraySegment CreateArraySegment(T[] data) + where T : struct + { + const int arraySegmentPadding = 7; + var newData = new T[data.Length + 2 * arraySegmentPadding]; + Array.Copy(data, 0, newData, arraySegmentPadding, data.Length); + return new ArraySegment(newData, arraySegmentPadding, data.Length); } [FlatBuffersTestMethod] @@ -578,10 +642,17 @@ namespace FlatBuffers.Test // create a null array and try to put it into the buffer float[] data = null; Assert.Throws(() => uut.Put(1024, data)); + + ArraySegment dataArraySegment = default; + Assert.Throws(() => uut.Put(1024, dataArraySegment)); + + IntPtr dataPtr = IntPtr.Zero; + int dataPtrLength = 100; + Assert.Throws(() => uut.Put(1024, dataPtr, dataPtrLength)); } [FlatBuffersTestMethod] - public void ByteBuffer_Put_Array_Empty_Throws() + public unsafe void ByteBuffer_Put_Array_Empty_Throws() { // Create the Byte Buffer var uut = new ByteBuffer(1024); @@ -589,6 +660,32 @@ namespace FlatBuffers.Test // create an array of length == 0, and try to put it into the buffer float[] data = new float[0]; Assert.Throws(() => uut.Put(1024, data)); + + var dataArraySegment = new ArraySegment(new float[10], 5, 0); + Assert.Throws(() => uut.Put(1024, dataArraySegment)); + + fixed(float* floatPtr = data) + { + var dataPtr = (IntPtr)floatPtr; + var dataPtrLength = 0; + Assert.Throws(() => uut.Put(1024, dataPtr, dataPtrLength)); + } + } + + [FlatBuffersTestMethod] + public unsafe void ByteBuffer_Put_IntPtr_NegativeSize_Throws() + { + // Create the Byte Buffer + var uut = new ByteBuffer(1024); + + // create an array of length == 0, and try to put it into the buffer + float[] data = new float[10]; + fixed(float* floatPtr = data) + { + var dataPtr = (IntPtr)floatPtr; + var dataPtrLength = -1; + Assert.Throws(() => uut.Put(1024, dataPtr, dataPtrLength)); + } } #pragma warning disable 0169 @@ -601,7 +698,7 @@ namespace FlatBuffers.Test #pragma warning restore 0169 [FlatBuffersTestMethod] - public void ByteBuffer_Put_Array_IncorrectType_Throws() + public unsafe void ByteBuffer_Put_Array_IncorrectType_Throws() { // Create the Byte Buffer var uut = new ByteBuffer(1024); @@ -610,6 +707,16 @@ namespace FlatBuffers.Test // able to be put into the buffer var data = new dummyStruct[10]; Assert.Throws(() => uut.Put(1024, data)); + + var dataArraySegment = new ArraySegment(data); + Assert.Throws(() => uut.Put(1024, dataArraySegment)); + + fixed(dummyStruct* floatPtr = data) + { + var dataPtr = (IntPtr)floatPtr; + var dataPtrLength = data.Length * sizeof(dummyStruct); + Assert.Throws(() => uut.Put(1024, dataPtr, dataPtrLength)); + } } [FlatBuffersTestMethod] diff --git a/tests/FlatBuffers.Test/FlatBufferBuilderTests.cs b/tests/FlatBuffers.Test/FlatBufferBuilderTests.cs index e2b72c7ee..290f45e27 100644 --- a/tests/FlatBuffers.Test/FlatBufferBuilderTests.cs +++ b/tests/FlatBuffers.Test/FlatBufferBuilderTests.cs @@ -553,6 +553,18 @@ namespace FlatBuffers.Test Assert.Throws(() => fbb.Add(data)); } + + [FlatBuffersTestMethod] + public unsafe void FlatBufferBuilder_Add_Array_UnsupportedType_Throws() + { + var fbb = CreateBuffer(false); + + var storedOffset = fbb.Offset; + + // Construct the data array + var data = new DummyStruct[10]; + Assert.Throws(() => fbb.Add(data)); + } [FlatBuffersTestMethod] public void FlatBufferBuilder_Add_Array_Empty_Noop() @@ -570,6 +582,159 @@ namespace FlatBuffers.Test var endOffset = fbb.Offset; Assert.AreEqual(endOffset, storedOffset); } + + [FlatBuffersTestMethod] + public void FlatBufferBuilder_Add_ArraySegment_Default_Throws() + { + var fbb = CreateBuffer(false); + + // Construct the data array + ArraySegment data = default; + + Assert.Throws(() => fbb.Add(data)); + } + + [FlatBuffersTestMethod] + public unsafe void FlatBufferBuilder_Add_ArraySegment_UnsupportedType_Throws() + { + var fbb = CreateBuffer(false); + + var storedOffset = fbb.Offset; + + // Construct the data array + var array = new DummyStruct[10]; + var data = new ArraySegment(array); + Assert.Throws(() => fbb.Add(data)); + } + + [FlatBuffersTestMethod] + public void FlatBufferBuilder_Add_ArraySegment_Empty_Noop() + { + var fbb = CreateBuffer(false); + + var storedOffset = fbb.Offset; + + // Construct the data array + var array = new float[10]; + var data = new ArraySegment(array, 5, 0); + fbb.Add(data); + + // Make sure the offset didn't change since nothing + // was really added + var endOffset = fbb.Offset; + Assert.AreEqual(endOffset, storedOffset); + } + + [FlatBuffersTestMethod] + public void FlatBufferBuilder_Add_IntPtr_Zero_Throws() + { + var fbb = CreateBuffer(false); + + // Construct the data array + var data = IntPtr.Zero; + var length = 100; + + Assert.Throws(() => fbb.Add(data, length)); + } + + [FlatBuffersTestMethod] + public unsafe void FlatBufferBuilder_Add_IntPtr_SizeNegative_Throws() + { + var fbb = CreateBuffer(false); + + // Construct the data array + var array = new float[10]; + fixed(float* ptr = array) + { + var data = (IntPtr)ptr; + var length = -1; + Assert.Throws(() => fbb.Add(data, length)); + } + } + + [FlatBuffersTestMethod] + public void FlatBufferBuilder_Add_IntPtr_Zero_Empty_Noop() + { + var fbb = CreateBuffer(false); + + var storedOffset = fbb.Offset; + + // Construct the data array + var data = IntPtr.Zero; + var length = 0; + + fbb.Add(data, length); + + // make sure that a length of 0 doesn't throw also if ptr is Zero as well + // and that nothing was really added + var endOffset = fbb.Offset; + Assert.AreEqual(endOffset, storedOffset); + } + + [FlatBuffersTestMethod] + public unsafe void FlatBufferBuilder_Add_IntPtr_Empty_Noop() + { + var fbb = CreateBuffer(false); + + var storedOffset = fbb.Offset; + + // Construct the data array + var array = new float[10]; + fixed(float* ptr = array) + { + var data = (IntPtr)ptr; + var length = 0; + fbb.Add(data, length); + } + + // Make sure the offset didn't change since nothing + // was really added + var endOffset = fbb.Offset; + Assert.AreEqual(endOffset, storedOffset); + } + + [FlatBuffersTestMethod] + public unsafe void FlatBufferBuilder_Add_IntPtr_SizeInBytesNotMatchingDataType_Throws() + { + var fbb = CreateBuffer(false); + + var storedOffset = fbb.Offset; + + // Construct the data array + var array = new float[10]; + fixed(float* ptr = array) + { + const int invalidBytes = 1; + var data = (IntPtr)ptr; + // add some invalid bytes to the length + var length = 2 * sizeof(float) + invalidBytes; + + Assert.Throws(() => fbb.Add(data, length)); + } + } + + [FlatBuffersTestMethod] + public unsafe void FlatBufferBuilder_Add_IntPtr_UnsupportedType_Throws() + { + var fbb = CreateBuffer(false); + + var storedOffset = fbb.Offset; + + // Construct the data array + var array = new DummyStruct[10]; + fixed(DummyStruct* ptr = array) + { + var data = (IntPtr)ptr; + var length = 10 * sizeof(DummyStruct); + + Assert.Throws(() => fbb.Add(data, length)); + } + } + + private struct DummyStruct + { + int value; + } [FlatBuffersTestMethod] public void FlatBufferBuilder_Add_null_String() diff --git a/tests/FlatBuffers.Test/FlatBuffers.Core.Test.csproj b/tests/FlatBuffers.Test/FlatBuffers.Core.Test.csproj index 6cd4e7870..5b6fb21af 100644 --- a/tests/FlatBuffers.Test/FlatBuffers.Core.Test.csproj +++ b/tests/FlatBuffers.Test/FlatBuffers.Core.Test.csproj @@ -19,6 +19,14 @@ $(DefineConstants);ENABLE_SPAN_T + + true + + + + true + + FlatBuffers\ByteBuffer.cs diff --git a/tests/FlatBuffers.Test/FlatBuffers.Test.csproj b/tests/FlatBuffers.Test/FlatBuffers.Test.csproj index 1247599a3..53e25c454 100644 --- a/tests/FlatBuffers.Test/FlatBuffers.Test.csproj +++ b/tests/FlatBuffers.Test/FlatBuffers.Test.csproj @@ -21,6 +21,7 @@ TRACE;DEBUG prompt 4 + true pdbonly @@ -29,6 +30,7 @@ TRACE prompt 4 + true diff --git a/tests/MyGame/Example/Monster.cs b/tests/MyGame/Example/Monster.cs index 4a1138986..c258ffccc 100644 --- a/tests/MyGame/Example/Monster.cs +++ b/tests/MyGame/Example/Monster.cs @@ -335,6 +335,8 @@ public struct Monster : IFlatbufferObject public static void AddInventory(FlatBufferBuilder builder, VectorOffset inventoryOffset) { builder.AddOffset(5, inventoryOffset.Value, 0); } public static VectorOffset CreateInventoryVector(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddByte(data[i]); return builder.EndVector(); } public static VectorOffset CreateInventoryVectorBlock(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateInventoryVectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(1, data.Count, 1); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateInventoryVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartInventoryVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); } public static void AddColor(FlatBufferBuilder builder, MyGame.Example.Color color) { builder.AddByte(6, (byte)color, 8); } public static void AddTestType(FlatBufferBuilder builder, MyGame.Example.Any testType) { builder.AddByte(7, (byte)testType, 0); } @@ -344,15 +346,21 @@ public struct Monster : IFlatbufferObject public static void AddTestarrayofstring(FlatBufferBuilder builder, VectorOffset testarrayofstringOffset) { builder.AddOffset(10, testarrayofstringOffset.Value, 0); } public static VectorOffset CreateTestarrayofstringVector(FlatBufferBuilder builder, StringOffset[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); } public static VectorOffset CreateTestarrayofstringVectorBlock(FlatBufferBuilder builder, StringOffset[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateTestarrayofstringVectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateTestarrayofstringVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartTestarrayofstringVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); } public static void AddTestarrayoftables(FlatBufferBuilder builder, VectorOffset testarrayoftablesOffset) { builder.AddOffset(11, testarrayoftablesOffset.Value, 0); } public static VectorOffset CreateTestarrayoftablesVector(FlatBufferBuilder builder, Offset[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); } public static VectorOffset CreateTestarrayoftablesVectorBlock(FlatBufferBuilder builder, Offset[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateTestarrayoftablesVectorBlock(FlatBufferBuilder builder, ArraySegment> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateTestarrayoftablesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add>(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartTestarrayoftablesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); } public static void AddEnemy(FlatBufferBuilder builder, Offset enemyOffset) { builder.AddOffset(12, enemyOffset.Value, 0); } public static void AddTestnestedflatbuffer(FlatBufferBuilder builder, VectorOffset testnestedflatbufferOffset) { builder.AddOffset(13, testnestedflatbufferOffset.Value, 0); } public static VectorOffset CreateTestnestedflatbufferVector(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddByte(data[i]); return builder.EndVector(); } public static VectorOffset CreateTestnestedflatbufferVectorBlock(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateTestnestedflatbufferVectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(1, data.Count, 1); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateTestnestedflatbufferVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartTestnestedflatbufferVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); } public static void AddTestempty(FlatBufferBuilder builder, Offset testemptyOffset) { builder.AddOffset(14, testemptyOffset.Value, 0); } public static void AddTestbool(FlatBufferBuilder builder, bool testbool) { builder.AddBool(15, testbool, false); } @@ -367,6 +375,8 @@ public struct Monster : IFlatbufferObject public static void AddTestarrayofbools(FlatBufferBuilder builder, VectorOffset testarrayofboolsOffset) { builder.AddOffset(24, testarrayofboolsOffset.Value, 0); } public static VectorOffset CreateTestarrayofboolsVector(FlatBufferBuilder builder, bool[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddBool(data[i]); return builder.EndVector(); } public static VectorOffset CreateTestarrayofboolsVectorBlock(FlatBufferBuilder builder, bool[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateTestarrayofboolsVectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(1, data.Count, 1); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateTestarrayofboolsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartTestarrayofboolsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); } public static void AddTestf(FlatBufferBuilder builder, float testf) { builder.AddFloat(25, testf, 3.14159f); } public static void AddTestf2(FlatBufferBuilder builder, float testf2) { builder.AddFloat(26, testf2, 3.0f); } @@ -374,46 +384,64 @@ public struct Monster : IFlatbufferObject public static void AddTestarrayofstring2(FlatBufferBuilder builder, VectorOffset testarrayofstring2Offset) { builder.AddOffset(28, testarrayofstring2Offset.Value, 0); } public static VectorOffset CreateTestarrayofstring2Vector(FlatBufferBuilder builder, StringOffset[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); } public static VectorOffset CreateTestarrayofstring2VectorBlock(FlatBufferBuilder builder, StringOffset[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateTestarrayofstring2VectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateTestarrayofstring2VectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartTestarrayofstring2Vector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); } public static void AddTestarrayofsortedstruct(FlatBufferBuilder builder, VectorOffset testarrayofsortedstructOffset) { builder.AddOffset(29, testarrayofsortedstructOffset.Value, 0); } public static void StartTestarrayofsortedstructVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 4); } public static void AddFlex(FlatBufferBuilder builder, VectorOffset flexOffset) { builder.AddOffset(30, flexOffset.Value, 0); } public static VectorOffset CreateFlexVector(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddByte(data[i]); return builder.EndVector(); } public static VectorOffset CreateFlexVectorBlock(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateFlexVectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(1, data.Count, 1); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateFlexVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartFlexVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); } public static void AddTest5(FlatBufferBuilder builder, VectorOffset test5Offset) { builder.AddOffset(31, test5Offset.Value, 0); } public static void StartTest5Vector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 2); } public static void AddVectorOfLongs(FlatBufferBuilder builder, VectorOffset vectorOfLongsOffset) { builder.AddOffset(32, vectorOfLongsOffset.Value, 0); } public static VectorOffset CreateVectorOfLongsVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); } public static VectorOffset CreateVectorOfLongsVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateVectorOfLongsVectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateVectorOfLongsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartVectorOfLongsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); } public static void AddVectorOfDoubles(FlatBufferBuilder builder, VectorOffset vectorOfDoublesOffset) { builder.AddOffset(33, vectorOfDoublesOffset.Value, 0); } public static VectorOffset CreateVectorOfDoublesVector(FlatBufferBuilder builder, double[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddDouble(data[i]); return builder.EndVector(); } public static VectorOffset CreateVectorOfDoublesVectorBlock(FlatBufferBuilder builder, double[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateVectorOfDoublesVectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateVectorOfDoublesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartVectorOfDoublesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); } public static void AddParentNamespaceTest(FlatBufferBuilder builder, Offset parentNamespaceTestOffset) { builder.AddOffset(34, parentNamespaceTestOffset.Value, 0); } public static void AddVectorOfReferrables(FlatBufferBuilder builder, VectorOffset vectorOfReferrablesOffset) { builder.AddOffset(35, vectorOfReferrablesOffset.Value, 0); } public static VectorOffset CreateVectorOfReferrablesVector(FlatBufferBuilder builder, Offset[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); } public static VectorOffset CreateVectorOfReferrablesVectorBlock(FlatBufferBuilder builder, Offset[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateVectorOfReferrablesVectorBlock(FlatBufferBuilder builder, ArraySegment> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateVectorOfReferrablesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add>(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartVectorOfReferrablesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); } public static void AddSingleWeakReference(FlatBufferBuilder builder, ulong singleWeakReference) { builder.AddUlong(36, singleWeakReference, 0); } public static void AddVectorOfWeakReferences(FlatBufferBuilder builder, VectorOffset vectorOfWeakReferencesOffset) { builder.AddOffset(37, vectorOfWeakReferencesOffset.Value, 0); } public static VectorOffset CreateVectorOfWeakReferencesVector(FlatBufferBuilder builder, ulong[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddUlong(data[i]); return builder.EndVector(); } public static VectorOffset CreateVectorOfWeakReferencesVectorBlock(FlatBufferBuilder builder, ulong[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateVectorOfWeakReferencesVectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateVectorOfWeakReferencesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartVectorOfWeakReferencesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); } public static void AddVectorOfStrongReferrables(FlatBufferBuilder builder, VectorOffset vectorOfStrongReferrablesOffset) { builder.AddOffset(38, vectorOfStrongReferrablesOffset.Value, 0); } public static VectorOffset CreateVectorOfStrongReferrablesVector(FlatBufferBuilder builder, Offset[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); } public static VectorOffset CreateVectorOfStrongReferrablesVectorBlock(FlatBufferBuilder builder, Offset[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateVectorOfStrongReferrablesVectorBlock(FlatBufferBuilder builder, ArraySegment> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateVectorOfStrongReferrablesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add>(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartVectorOfStrongReferrablesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); } public static void AddCoOwningReference(FlatBufferBuilder builder, ulong coOwningReference) { builder.AddUlong(39, coOwningReference, 0); } public static void AddVectorOfCoOwningReferences(FlatBufferBuilder builder, VectorOffset vectorOfCoOwningReferencesOffset) { builder.AddOffset(40, vectorOfCoOwningReferencesOffset.Value, 0); } public static VectorOffset CreateVectorOfCoOwningReferencesVector(FlatBufferBuilder builder, ulong[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddUlong(data[i]); return builder.EndVector(); } public static VectorOffset CreateVectorOfCoOwningReferencesVectorBlock(FlatBufferBuilder builder, ulong[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateVectorOfCoOwningReferencesVectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateVectorOfCoOwningReferencesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartVectorOfCoOwningReferencesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); } public static void AddNonOwningReference(FlatBufferBuilder builder, ulong nonOwningReference) { builder.AddUlong(41, nonOwningReference, 0); } public static void AddVectorOfNonOwningReferences(FlatBufferBuilder builder, VectorOffset vectorOfNonOwningReferencesOffset) { builder.AddOffset(42, vectorOfNonOwningReferencesOffset.Value, 0); } public static VectorOffset CreateVectorOfNonOwningReferencesVector(FlatBufferBuilder builder, ulong[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddUlong(data[i]); return builder.EndVector(); } public static VectorOffset CreateVectorOfNonOwningReferencesVectorBlock(FlatBufferBuilder builder, ulong[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateVectorOfNonOwningReferencesVectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateVectorOfNonOwningReferencesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartVectorOfNonOwningReferencesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); } public static void AddAnyUniqueType(FlatBufferBuilder builder, MyGame.Example.AnyUniqueAliases anyUniqueType) { builder.AddByte(43, (byte)anyUniqueType, 0); } public static void AddAnyUnique(FlatBufferBuilder builder, int anyUniqueOffset) { builder.AddOffset(44, anyUniqueOffset, 0); } @@ -422,15 +450,21 @@ public struct Monster : IFlatbufferObject public static void AddVectorOfEnums(FlatBufferBuilder builder, VectorOffset vectorOfEnumsOffset) { builder.AddOffset(47, vectorOfEnumsOffset.Value, 0); } public static VectorOffset CreateVectorOfEnumsVector(FlatBufferBuilder builder, MyGame.Example.Color[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddByte((byte)data[i]); return builder.EndVector(); } public static VectorOffset CreateVectorOfEnumsVectorBlock(FlatBufferBuilder builder, MyGame.Example.Color[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateVectorOfEnumsVectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(1, data.Count, 1); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateVectorOfEnumsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartVectorOfEnumsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); } public static void AddSignedEnum(FlatBufferBuilder builder, MyGame.Example.Race signedEnum) { builder.AddSbyte(48, (sbyte)signedEnum, -1); } public static void AddTestrequirednestedflatbuffer(FlatBufferBuilder builder, VectorOffset testrequirednestedflatbufferOffset) { builder.AddOffset(49, testrequirednestedflatbufferOffset.Value, 0); } public static VectorOffset CreateTestrequirednestedflatbufferVector(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddByte(data[i]); return builder.EndVector(); } public static VectorOffset CreateTestrequirednestedflatbufferVectorBlock(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateTestrequirednestedflatbufferVectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(1, data.Count, 1); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateTestrequirednestedflatbufferVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartTestrequirednestedflatbufferVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); } public static void AddScalarKeySortedTables(FlatBufferBuilder builder, VectorOffset scalarKeySortedTablesOffset) { builder.AddOffset(50, scalarKeySortedTablesOffset.Value, 0); } public static VectorOffset CreateScalarKeySortedTablesVector(FlatBufferBuilder builder, Offset[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); } public static VectorOffset CreateScalarKeySortedTablesVectorBlock(FlatBufferBuilder builder, Offset[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateScalarKeySortedTablesVectorBlock(FlatBufferBuilder builder, ArraySegment> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateScalarKeySortedTablesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add>(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartScalarKeySortedTablesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); } public static void AddNativeInline(FlatBufferBuilder builder, Offset nativeInlineOffset) { builder.AddStruct(51, nativeInlineOffset.Value, 0); } public static void AddLongEnumNonEnumDefault(FlatBufferBuilder builder, MyGame.Example.LongEnum longEnumNonEnumDefault) { builder.AddUlong(52, (ulong)longEnumNonEnumDefault, 0); } diff --git a/tests/MyGame/Example/TypeAliases.cs b/tests/MyGame/Example/TypeAliases.cs index 1801dc886..30b783a3b 100644 --- a/tests/MyGame/Example/TypeAliases.cs +++ b/tests/MyGame/Example/TypeAliases.cs @@ -101,10 +101,14 @@ public struct TypeAliases : IFlatbufferObject public static void AddV8(FlatBufferBuilder builder, VectorOffset v8Offset) { builder.AddOffset(10, v8Offset.Value, 0); } public static VectorOffset CreateV8Vector(FlatBufferBuilder builder, sbyte[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddSbyte(data[i]); return builder.EndVector(); } public static VectorOffset CreateV8VectorBlock(FlatBufferBuilder builder, sbyte[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateV8VectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(1, data.Count, 1); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateV8VectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartV8Vector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); } public static void AddVf64(FlatBufferBuilder builder, VectorOffset vf64Offset) { builder.AddOffset(11, vf64Offset.Value, 0); } public static VectorOffset CreateVf64Vector(FlatBufferBuilder builder, double[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddDouble(data[i]); return builder.EndVector(); } public static VectorOffset CreateVf64VectorBlock(FlatBufferBuilder builder, double[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateVf64VectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateVf64VectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartVf64Vector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); } public static Offset EndTypeAliases(FlatBufferBuilder builder) { int o = builder.EndTable(); diff --git a/tests/MyGame/MonsterExtra.cs b/tests/MyGame/MonsterExtra.cs index 6af993288..361a82b49 100644 --- a/tests/MyGame/MonsterExtra.cs +++ b/tests/MyGame/MonsterExtra.cs @@ -92,10 +92,14 @@ public struct MonsterExtra : IFlatbufferObject public static void AddDvec(FlatBufferBuilder builder, VectorOffset dvecOffset) { builder.AddOffset(8, dvecOffset.Value, 0); } public static VectorOffset CreateDvecVector(FlatBufferBuilder builder, double[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddDouble(data[i]); return builder.EndVector(); } public static VectorOffset CreateDvecVectorBlock(FlatBufferBuilder builder, double[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateDvecVectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateDvecVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartDvecVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); } public static void AddFvec(FlatBufferBuilder builder, VectorOffset fvecOffset) { builder.AddOffset(9, fvecOffset.Value, 0); } public static VectorOffset CreateFvecVector(FlatBufferBuilder builder, float[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddFloat(data[i]); return builder.EndVector(); } public static VectorOffset CreateFvecVectorBlock(FlatBufferBuilder builder, float[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateFvecVectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateFvecVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartFvecVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); } public static Offset EndMonsterExtra(FlatBufferBuilder builder) { int o = builder.EndTable(); diff --git a/tests/union_vector/Movie.cs b/tests/union_vector/Movie.cs index f85daa6a7..8ef5f4018 100644 --- a/tests/union_vector/Movie.cs +++ b/tests/union_vector/Movie.cs @@ -57,10 +57,14 @@ public struct Movie : IFlatbufferObject public static void AddCharactersType(FlatBufferBuilder builder, VectorOffset charactersTypeOffset) { builder.AddOffset(2, charactersTypeOffset.Value, 0); } public static VectorOffset CreateCharactersTypeVector(FlatBufferBuilder builder, Character[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddByte((byte)data[i]); return builder.EndVector(); } public static VectorOffset CreateCharactersTypeVectorBlock(FlatBufferBuilder builder, Character[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateCharactersTypeVectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(1, data.Count, 1); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateCharactersTypeVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartCharactersTypeVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); } public static void AddCharacters(FlatBufferBuilder builder, VectorOffset charactersOffset) { builder.AddOffset(3, charactersOffset.Value, 0); } public static VectorOffset CreateCharactersVector(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i]); return builder.EndVector(); } public static VectorOffset CreateCharactersVectorBlock(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateCharactersVectorBlock(FlatBufferBuilder builder, ArraySegment data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateCharactersVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add(dataPtr, sizeInBytes); return builder.EndVector(); } public static void StartCharactersVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); } public static Offset EndMovie(FlatBufferBuilder builder) { int o = builder.EndTable();