From 7b50004ec9a1b86db2b1b61a9906e52227f62b35 Mon Sep 17 00:00:00 2001 From: Derek Bailey Date: Thu, 26 Jul 2018 13:44:40 -0700 Subject: [PATCH] Performance Increase of Vector of Structures using .NET BlockCopy (#4830) * Added GetArray() method for accessing vectors of structures in C# using Buffer.Blockcopy(). * Added GetArray() method for accessing vectors of structures in C# using Buffer.Blockcopy(). Added CreateVectorBlock() method to add a typed array using Buffer.BlockCopy() to speed up creation of vector of arrays New Lua files for namespace test * fixed c++ style issue --- net/FlatBuffers/ByteBuffer.cs | 118 +++++++- net/FlatBuffers/FlatBufferBuilder.cs | 43 +++ net/FlatBuffers/Table.cs | 23 ++ src/idl_gen_general.cpp | 25 ++ tests/FlatBuffers.Test/ByteBufferTests.cs | 268 +++++++++++++++++- .../FlatBufferBuilderTests.cs | 105 +++++++ .../FlatBuffersExampleTests.cs | 10 + tests/MyGame/Example/Monster.cs | 24 ++ tests/MyGame/Example/Stat.cs | 1 + tests/MyGame/Example/TypeAliases.cs | 4 + tests/monster_test.bfbs | Bin 6352 -> 6432 bytes .../namespace_test2_generated.ts | 20 +- 12 files changed, 625 insertions(+), 16 deletions(-) diff --git a/net/FlatBuffers/ByteBuffer.cs b/net/FlatBuffers/ByteBuffer.cs index 878e740b5..307a98fad 100644 --- a/net/FlatBuffers/ByteBuffer.cs +++ b/net/FlatBuffers/ByteBuffer.cs @@ -30,6 +30,7 @@ // using System; +using System.Collections.Generic; using System.IO; using System.Text; @@ -91,19 +92,78 @@ namespace FlatBuffers public byte[] ToArray(int pos, int len) { - byte[] arr = new byte[len]; - Buffer.BlockCopy(_buffer, pos, arr, 0, len); + return ToArray(pos, len); + } + + /// + /// A lookup of type sizes. Used instead of Marshal.SizeOf() which has additional + /// overhead, but also is compatible with generic functions for simplified code. + /// + private static Dictionary genericSizes = new Dictionary() + { + { typeof(bool), sizeof(bool) }, + { typeof(float), sizeof(float) }, + { typeof(double), sizeof(double) }, + { typeof(sbyte), sizeof(sbyte) }, + { typeof(byte), sizeof(byte) }, + { typeof(short), sizeof(short) }, + { typeof(ushort), sizeof(ushort) }, + { typeof(int), sizeof(int) }, + { typeof(uint), sizeof(uint) }, + { typeof(ulong), sizeof(ulong) }, + { typeof(long), sizeof(long) }, + }; + + /// + /// Get the wire-size (in bytes) of a type supported by flatbuffers. + /// + /// The type to get the wire size of + /// + public static int SizeOf() + { + return genericSizes[typeof(T)]; + } + + /// + /// Checks if the Type provided is supported as scalar value + /// + /// The Type to check + /// True if the type is a scalar type that is supported, falsed otherwise + public static bool IsSupportedType() + { + return genericSizes.ContainsKey(typeof(T)); + } + + /// + /// Get the wire-size (in bytes) of an typed array + /// + /// The type of the array + /// The array to get the size of + /// The number of bytes the array takes on wire + public static int ArraySize(T[] x) + { + return SizeOf() * x.Length; + } + + // Get a portion of the buffer casted into an array of type T, given + // the buffer position and length. + public T[] ToArray(int pos, int len) + where T: struct + { + AssertOffsetAndLength(pos, len); + T[] arr = new T[len]; + Buffer.BlockCopy(_buffer, pos, arr, 0, ArraySize(arr)); return arr; } public byte[] ToSizedArray() { - return ToArray(Position, Length - Position); + return ToArray(Position, Length - Position); } public byte[] ToFullArray() { - return ToArray(0, Length); + return ToArray(0, Length); } public ArraySegment ToArraySegment(int pos, int len) @@ -368,6 +428,56 @@ namespace FlatBuffers WriteLittleEndian(offset, sizeof(double), ulonghelper[0]); } + /// + /// Copies an array of type T into this buffer, ending at the given + /// offset into this buffer. The starting offset is calculated based on the length + /// of the array 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 to copy data from + /// The 'start' location of this buffer now, after the copy completed + public int Put(int offset, T[] x) + where T : struct + { + if(x == null) + { + throw new ArgumentNullException("Cannot put a null array"); + } + + if(x.Length == 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) + { + int numBytes = ByteBuffer.ArraySize(x); + offset -= numBytes; + AssertOffsetAndLength(offset, numBytes); + // if we are LE, just do a block copy + Buffer.BlockCopy(x, 0, _buffer, offset, numBytes); + } + 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; + } + + #endif // UNSAFE_BYTEBUFFER public sbyte GetSbyte(int index) diff --git a/net/FlatBuffers/FlatBufferBuilder.cs b/net/FlatBuffers/FlatBufferBuilder.cs index a2224498d..33bba969d 100644 --- a/net/FlatBuffers/FlatBufferBuilder.cs +++ b/net/FlatBuffers/FlatBufferBuilder.cs @@ -179,6 +179,18 @@ namespace FlatBuffers _bb.PutFloat(_space -= sizeof(float), x); } + /// + /// Puts an array of type T into this builder at the + /// current offset + /// + /// The type of the input data + /// The array to copy data from + public void Put(T[] x) + where T : struct + { + _space = _bb.Put(_space, x); + } + public void PutDouble(double x) { _bb.PutDouble(_space -= sizeof(double), x); @@ -245,6 +257,37 @@ namespace FlatBuffers /// The `float` to add to the buffer. public void AddFloat(float x) { Prep(sizeof(float), 0); PutFloat(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 to copy data from + public void Add(T[] x) + where T : struct + { + if (x == null) + { + throw new ArgumentNullException("Cannot add a null array"); + } + + if( x.Length == 0) + { + // don't do anything if the array is empty + return; + } + + if(!ByteBuffer.IsSupportedType()) + { + throw new ArgumentException("Cannot add this Type array to the builder"); + } + + 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)); + Put(x); + } + /// /// Add a `double` to the buffer (aligns the data and grows if necessary). /// diff --git a/net/FlatBuffers/Table.cs b/net/FlatBuffers/Table.cs index 4a188ff88..07db5f423 100644 --- a/net/FlatBuffers/Table.cs +++ b/net/FlatBuffers/Table.cs @@ -94,6 +94,29 @@ namespace FlatBuffers return bb.ToArraySegment(pos, len); } + // Get the data of a vector whoses offset is stored at "offset" in this object as an + // T[]. If the vector is not present in the ByteBuffer, then a null value will be + // returned. + public T[] __vector_as_array(int offset) + where T : struct + { + if(!BitConverter.IsLittleEndian) + { + throw new NotSupportedException("Getting typed arrays on a Big Endian " + + "system is not support"); + } + + var o = this.__offset(offset); + if (0 == o) + { + return null; + } + + var pos = this.__vector(o); + var len = this.__vector_len(o); + return bb.ToArray(pos, len); + } + // Initialize any Table-derived type to point to the union at the given offset. public T __union(int offset) where T : struct, IFlatbufferObject { diff --git a/src/idl_gen_general.cpp b/src/idl_gen_general.cpp index d3cc79b2f..27eb8c405 100644 --- a/src/idl_gen_general.cpp +++ b/src/idl_gen_general.cpp @@ -1102,6 +1102,18 @@ class GeneralGenerator : public BaseGenerator { code += lang_.accessor_prefix + "__vector_as_arraysegment("; code += NumToString(field.value.offset); code += "); }\n"; + + // For direct blockcopying the data into a typed array + code += " public "; + code += GenTypeBasic(field.value.type.VectorType()); + code += "[] Get"; + code += MakeCamel(field.name, lang_.first_camel_upper); + code += "Array() { return "; + code += lang_.accessor_prefix + "__vector_as_array<"; + code += GenTypeBasic(field.value.type.VectorType()); + code += ">("; + code += NumToString(field.value.offset); + code += "); }\n"; break; default: break; } @@ -1324,6 +1336,19 @@ class GeneralGenerator : public BaseGenerator { code += ".Value"; code += "); return "; code += "builder." + FunctionStart('E') + "ndVector(); }\n"; + // For C#, include a block copy method signature. + if (lang_.language == IDLOptions::kCSharp) { + code += " public static " + GenVectorOffsetType() + " "; + code += FunctionStart('C') + "reate"; + code += MakeCamel(field.name); + code += "VectorBlock(FlatBufferBuilder builder, "; + code += GenTypeBasic(vector_type) + "[] data) "; + code += "{ builder." + FunctionStart('S') + "tartVector("; + code += NumToString(elem_size); + code += ", data." + FunctionStart('L') + "ength, "; + code += NumToString(alignment); + code += "); builder.Add(data); 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 58bd71e59..1c33a2f56 100644 --- a/tests/FlatBuffers.Test/ByteBufferTests.cs +++ b/tests/FlatBuffers.Test/ByteBufferTests.cs @@ -100,7 +100,7 @@ namespace FlatBuffers.Test Assert.AreEqual(0x0A, buffer[3]); } - #if !BYTEBUFFER_NO_BOUNDS_CHECK +#if !BYTEBUFFER_NO_BOUNDS_CHECK [FlatBuffersTestMethod] public void ByteBuffer_PutIntCannotPutAtOffsetPastLength() { @@ -178,7 +178,7 @@ namespace FlatBuffers.Test public void ByteBuffer_GetByteChecksOffset() { var uut = new ByteBuffer(1); - Assert.Throws(()=>uut.Get(1)); + Assert.Throws(() => uut.Get(1)); } #endif @@ -344,5 +344,269 @@ namespace FlatBuffers.Test uut.Position = 1; uut = uut.Duplicate(); Assert.AreEqual(0x0A, uut.Get(3)); } + + [FlatBuffersTestMethod] + public void ByteBuffer_To_Array_Float() + { + const int len = 9; + + // Construct the data array + var fData = new float[len]; + fData[0] = 1.0079F; + fData[1] = 4.0026F; + fData[2] = 6.941F; + fData[3] = 9.0122F; + fData[4] = 10.811F; + fData[5] = 12.0107F; + fData[6] = 14.0067F; + fData[7] = 15.9994F; + fData[8] = 18.9984F; + + // Tranfer it to a byte array + var buffer = new byte[sizeof(float) * fData.Length]; + Buffer.BlockCopy(fData, 0, buffer, 0, buffer.Length); + + // Create the Byte Buffer from byte array + var uut = new ByteBuffer(buffer); + + // Get the full array back out and ensure they are equivalent + var bbArray = uut.ToArray(0, len); + Assert.ArrayEqual(fData, bbArray); + + // Get a portion of the full array back out and ensure the + // subrange agrees + var bbArray2 = uut.ToArray(4, len - 1); + Assert.AreEqual(bbArray2.Length, len - 1); + for (int i = 1; i < len - 1; i++) + { + Assert.AreEqual(fData[i], bbArray2[i - 1]); + } + + // Get a sub portion of the full array back out and ensure the + // subrange agrees + var bbArray3 = uut.ToArray(8, len - 4); + Assert.AreEqual(bbArray3.Length, len - 4); + for (int i = 2; i < len - 4; i++) + { + Assert.AreEqual(fData[i], bbArray3[i - 2]); + } + } + + public void ByteBuffer_Put_Array_Helper(T[] 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.Length, nOffset); + + // Get the full array back out and ensure they are equivalent + var bbArray = uut.ToArray(nOffset, data.Length); + Assert.ArrayEqual(data, bbArray); + } + + [FlatBuffersTestMethod] + public void ByteBuffer_Put_Array_Float() + { + const int len = 9; + + // Construct the data array + var data = new float[len]; + data[0] = 1.0079F; + data[1] = 4.0026F; + data[2] = 6.941F; + data[3] = 9.0122F; + data[4] = 10.811F; + data[5] = 12.0107F; + data[6] = 14.0067F; + data[7] = 15.9994F; + data[8] = 18.9984F; + + ByteBuffer_Put_Array_Helper(data, sizeof(float)); + } + + [FlatBuffersTestMethod] + public void ByteBuffer_Put_Array_Double() + { + const int len = 9; + + // Construct the data array + var data = new double[len]; + data[0] = 1.0079; + data[1] = 4.0026; + data[2] = 6.941; + data[3] = 9.0122; + data[4] = 10.811; + data[5] = 12.0107; + data[6] = 14.0067; + data[7] = 15.9994; + data[8] = 18.9984; + + ByteBuffer_Put_Array_Helper(data, sizeof(double)); + } + + [FlatBuffersTestMethod] + public void ByteBuffer_Put_Array_Int() + { + const int len = 9; + + // Construct the data array + var data = new int[len]; + data[0] = 1; + data[1] = 4; + data[2] = 6; + data[3] = 9; + data[4] = 10; + data[5] = 12; + data[6] = 14; + data[7] = 15; + data[8] = 18; + + ByteBuffer_Put_Array_Helper(data, sizeof(int)); + } + + + [FlatBuffersTestMethod] + public void ByteBuffer_Put_Array_UInt() + { + const int len = 9; + + // Construct the data array + var data = new uint[len]; + data[0] = 1; + data[1] = 4; + data[2] = 6; + data[3] = 9; + data[4] = 10; + data[5] = 12; + data[6] = 14; + data[7] = 15; + data[8] = 18; + + ByteBuffer_Put_Array_Helper(data, sizeof(uint)); + } + + [FlatBuffersTestMethod] + public void ByteBuffer_Put_Array_Bool() + { + const int len = 9; + + // Construct the data array + var data = new bool[len]; + data[0] = true; + data[1] = true; + data[2] = false; + data[3] = true; + data[4] = false; + data[5] = true; + data[6] = true; + data[7] = true; + data[8] = false; + + ByteBuffer_Put_Array_Helper(data, sizeof(bool)); + } + + [FlatBuffersTestMethod] + public void ByteBuffer_Put_Array_Long() + { + const int len = 9; + + // Construct the data array + var data = new long[len]; + data[0] = 1; + data[1] = 4; + data[2] = 6; + data[3] = 9; + data[4] = 10; + data[5] = 12; + data[6] = 14; + data[7] = 15; + data[8] = 18; + + ByteBuffer_Put_Array_Helper(data, sizeof(long)); + } + + [FlatBuffersTestMethod] + public void ByteBuffer_Put_Array_Byte() + { + const int len = 9; + + // Construct the data array + var data = new byte[len]; + data[0] = 1; + data[1] = 4; + data[2] = 6; + data[3] = 9; + data[4] = 10; + data[5] = 12; + data[6] = 14; + data[7] = 15; + data[8] = 18; + + ByteBuffer_Put_Array_Helper(data, sizeof(byte)); + } + + [FlatBuffersTestMethod] + public void ByteBuffer_Put_Array_SByte() + { + const int len = 9; + + // Construct the data array + var data = new sbyte[len]; + data[0] = 1; + data[1] = 4; + data[2] = 6; + data[3] = 9; + data[4] = 10; + data[5] = 12; + data[6] = 14; + data[7] = 15; + data[8] = 18; + + ByteBuffer_Put_Array_Helper(data, sizeof(sbyte)); + } + + [FlatBuffersTestMethod] + public void ByteBuffer_Put_Array_Null_Throws() + { + // Create the Byte Buffer + var uut = new ByteBuffer(1024); + + // create a null array and try to put it into the buffer + float[] data = null; + Assert.Throws(() => uut.Put(1024, data)); + } + + [FlatBuffersTestMethod] + public void ByteBuffer_Put_Array_Empty_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[0]; + Assert.Throws(() => uut.Put(1024, data)); + } + + private struct dummyStruct + { + int a; + float b; + } + + [FlatBuffersTestMethod] + public void ByteBuffer_Put_Array_IncorrectType_Throws() + { + // Create the Byte Buffer + var uut = new ByteBuffer(1024); + + // Create an array of dummy structures that shouldn't be + // able to be put into the buffer + var data = new dummyStruct[10]; + Assert.Throws(() => uut.Put(1024, data)); + } } } diff --git a/tests/FlatBuffers.Test/FlatBufferBuilderTests.cs b/tests/FlatBuffers.Test/FlatBufferBuilderTests.cs index f02df445e..4ddd9a8cb 100644 --- a/tests/FlatBuffers.Test/FlatBufferBuilderTests.cs +++ b/tests/FlatBuffers.Test/FlatBufferBuilderTests.cs @@ -14,6 +14,8 @@ * limitations under the License. */ +using System; + namespace FlatBuffers.Test { [FlatBuffersTestClass] @@ -245,5 +247,108 @@ namespace FlatBuffers.Test var endOffset = fbb.Offset; Assert.AreEqual(endOffset, storedOffset); } + + [FlatBuffersTestMethod] + public void FlatBufferBuilder_Add_Array_Float() + { + var fbb = CreateBuffer(false); + var storedOffset = fbb.Offset; + + const int len = 9; + + // Construct the data array + var data = new float[len]; + data[0] = 1.0079F; + data[1] = 4.0026F; + data[2] = 6.941F; + data[3] = 9.0122F; + data[4] = 10.811F; + data[5] = 12.0107F; + data[6] = 14.0067F; + data[7] = 15.9994F; + data[8] = 18.9984F; + + fbb.Add(data); + var endOffset = fbb.Offset; + Assert.AreEqual(endOffset, storedOffset + sizeof(float) * data.Length); + } + + [FlatBuffersTestMethod] + public void FlatBufferBuilder_Add_Array_Bool() + { + var fbb = CreateBuffer(false); + var storedOffset = fbb.Offset; + + const int len = 9; + + // Construct the data array + var data = new bool[len]; + data[0] = true; + data[1] = true; + data[2] = false; + data[3] = true; + data[4] = false; + data[5] = true; + data[6] = true; + data[7] = true; + data[8] = false; + + fbb.Add(data); + var endOffset = fbb.Offset; + Assert.AreEqual(endOffset, storedOffset + sizeof(bool) * data.Length); + } + + [FlatBuffersTestMethod] + public void FlatBufferBuilder_Add_Array_Double() + { + var fbb = CreateBuffer(false); + var storedOffset = fbb.Offset; + + const int len = 9; + + // Construct the data array + var data = new double[len]; + data[0] = 1.0079; + data[1] = 4.0026; + data[2] = 6.941; + data[3] = 9.0122; + data[4] = 10.811; + data[5] = 12.0107; + data[6] = 14.0067; + data[7] = 15.9994; + data[8] = 18.9984; + + fbb.Add(data); + var endOffset = fbb.Offset; + Assert.AreEqual(endOffset, storedOffset + sizeof(double) * data.Length); + } + + [FlatBuffersTestMethod] + public void FlatBufferBuilder_Add_Array_Null_Throws() + { + var fbb = CreateBuffer(false); + + // Construct the data array + float[] data = null; + + Assert.Throws(() => fbb.Add(data)); + } + + [FlatBuffersTestMethod] + public void FlatBufferBuilder_Add_Array_Empty_Noop() + { + var fbb = CreateBuffer(false); + + var storedOffset = fbb.Offset; + + // Construct an empty data array + float[] data = new float[0]; + fbb.Add(data); + + // Make sure the offset didn't change since nothing + // was really added + var endOffset = fbb.Offset; + Assert.AreEqual(endOffset, storedOffset); + } } } diff --git a/tests/FlatBuffers.Test/FlatBuffersExampleTests.cs b/tests/FlatBuffers.Test/FlatBuffersExampleTests.cs index 82d4fdf20..d438e0e44 100644 --- a/tests/FlatBuffers.Test/FlatBuffersExampleTests.cs +++ b/tests/FlatBuffers.Test/FlatBuffersExampleTests.cs @@ -221,6 +221,16 @@ namespace FlatBuffers.Test } Assert.AreEqual(10, invsum); + // Get the inventory as an array and subtract the + // sum to get it back to 0 + var inventoryArray = monster.GetInventoryArray(); + Assert.AreEqual(5, inventoryArray.Length); + foreach(var inv in inventoryArray) + { + invsum -= inv; + } + Assert.AreEqual(0, invsum); + var test0 = monster.Test4(0).Value; var test1 = monster.Test4(1).Value; Assert.AreEqual(2, monster.Test4Length); diff --git a/tests/MyGame/Example/Monster.cs b/tests/MyGame/Example/Monster.cs index b7844fb36..b3109e950 100644 --- a/tests/MyGame/Example/Monster.cs +++ b/tests/MyGame/Example/Monster.cs @@ -26,9 +26,11 @@ public struct Monster : IFlatbufferObject public bool MutateHp(short hp) { int o = __p.__offset(8); if (o != 0) { __p.bb.PutShort(o + __p.bb_pos, hp); return true; } else { return false; } } public string Name { get { int o = __p.__offset(10); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } } public ArraySegment? GetNameBytes() { return __p.__vector_as_arraysegment(10); } + public byte[] GetNameArray() { return __p.__vector_as_array(10); } public byte Inventory(int j) { int o = __p.__offset(14); return o != 0 ? __p.bb.Get(__p.__vector(o) + j * 1) : (byte)0; } public int InventoryLength { get { int o = __p.__offset(14); return o != 0 ? __p.__vector_len(o) : 0; } } public ArraySegment? GetInventoryBytes() { return __p.__vector_as_arraysegment(14); } + public byte[] GetInventoryArray() { return __p.__vector_as_array(14); } public bool MutateInventory(int j, byte inventory) { int o = __p.__offset(14); if (o != 0) { __p.bb.Put(__p.__vector(o) + j * 1, inventory); return true; } else { return false; } } public Color Color { get { int o = __p.__offset(16); return o != 0 ? (Color)__p.bb.GetSbyte(o + __p.bb_pos) : Color.Blue; } } public bool MutateColor(Color color) { int o = __p.__offset(16); if (o != 0) { __p.bb.PutSbyte(o + __p.bb_pos, (sbyte)color); return true; } else { return false; } } @@ -48,6 +50,7 @@ public struct Monster : IFlatbufferObject public byte Testnestedflatbuffer(int j) { int o = __p.__offset(30); return o != 0 ? __p.bb.Get(__p.__vector(o) + j * 1) : (byte)0; } public int TestnestedflatbufferLength { get { int o = __p.__offset(30); return o != 0 ? __p.__vector_len(o) : 0; } } public ArraySegment? GetTestnestedflatbufferBytes() { return __p.__vector_as_arraysegment(30); } + public byte[] GetTestnestedflatbufferArray() { return __p.__vector_as_array(30); } public Monster? GetTestnestedflatbufferAsMonster() { int o = __p.__offset(30); return o != 0 ? (Monster?)(new Monster()).__assign(__p.__indirect(__p.__vector(o)), __p.bb) : null; } public bool MutateTestnestedflatbuffer(int j, byte testnestedflatbuffer) { int o = __p.__offset(30); if (o != 0) { __p.bb.Put(__p.__vector(o) + j * 1, testnestedflatbuffer); return true; } else { return false; } } public Stat? Testempty { get { int o = __p.__offset(32); return o != 0 ? (Stat?)(new Stat()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } } @@ -72,6 +75,7 @@ public struct Monster : IFlatbufferObject public bool Testarrayofbools(int j) { int o = __p.__offset(52); return o != 0 ? 0!=__p.bb.Get(__p.__vector(o) + j * 1) : false; } public int TestarrayofboolsLength { get { int o = __p.__offset(52); return o != 0 ? __p.__vector_len(o) : 0; } } public ArraySegment? GetTestarrayofboolsBytes() { return __p.__vector_as_arraysegment(52); } + public bool[] GetTestarrayofboolsArray() { return __p.__vector_as_array(52); } public bool MutateTestarrayofbools(int j, bool testarrayofbools) { int o = __p.__offset(52); if (o != 0) { __p.bb.Put(__p.__vector(o) + j * 1, (byte)(testarrayofbools ? 1 : 0)); return true; } else { return false; } } public float Testf { get { int o = __p.__offset(54); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)3.14159f; } } public bool MutateTestf(float testf) { int o = __p.__offset(54); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, testf); return true; } else { return false; } } @@ -86,16 +90,19 @@ public struct Monster : IFlatbufferObject public byte Flex(int j) { int o = __p.__offset(64); return o != 0 ? __p.bb.Get(__p.__vector(o) + j * 1) : (byte)0; } public int FlexLength { get { int o = __p.__offset(64); return o != 0 ? __p.__vector_len(o) : 0; } } public ArraySegment? GetFlexBytes() { return __p.__vector_as_arraysegment(64); } + public byte[] GetFlexArray() { return __p.__vector_as_array(64); } public bool MutateFlex(int j, byte flex) { int o = __p.__offset(64); if (o != 0) { __p.bb.Put(__p.__vector(o) + j * 1, flex); return true; } else { return false; } } public Test? Test5(int j) { int o = __p.__offset(66); return o != 0 ? (Test?)(new Test()).__assign(__p.__vector(o) + j * 4, __p.bb) : null; } public int Test5Length { get { int o = __p.__offset(66); return o != 0 ? __p.__vector_len(o) : 0; } } public long VectorOfLongs(int j) { int o = __p.__offset(68); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; } public int VectorOfLongsLength { get { int o = __p.__offset(68); return o != 0 ? __p.__vector_len(o) : 0; } } public ArraySegment? GetVectorOfLongsBytes() { return __p.__vector_as_arraysegment(68); } + public long[] GetVectorOfLongsArray() { return __p.__vector_as_array(68); } public bool MutateVectorOfLongs(int j, long vector_of_longs) { int o = __p.__offset(68); if (o != 0) { __p.bb.PutLong(__p.__vector(o) + j * 8, vector_of_longs); return true; } else { return false; } } public double VectorOfDoubles(int j) { int o = __p.__offset(70); return o != 0 ? __p.bb.GetDouble(__p.__vector(o) + j * 8) : (double)0; } public int VectorOfDoublesLength { get { int o = __p.__offset(70); return o != 0 ? __p.__vector_len(o) : 0; } } public ArraySegment? GetVectorOfDoublesBytes() { return __p.__vector_as_arraysegment(70); } + public double[] GetVectorOfDoublesArray() { return __p.__vector_as_array(70); } public bool MutateVectorOfDoubles(int j, double vector_of_doubles) { int o = __p.__offset(70); if (o != 0) { __p.bb.PutDouble(__p.__vector(o) + j * 8, vector_of_doubles); return true; } else { return false; } } public MyGame.InParentNamespace? ParentNamespaceTest { get { int o = __p.__offset(72); return o != 0 ? (MyGame.InParentNamespace?)(new MyGame.InParentNamespace()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } } public Referrable? VectorOfReferrables(int j) { int o = __p.__offset(74); return o != 0 ? (Referrable?)(new Referrable()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; } @@ -106,6 +113,7 @@ public struct Monster : IFlatbufferObject public ulong VectorOfWeakReferences(int j) { int o = __p.__offset(78); return o != 0 ? __p.bb.GetUlong(__p.__vector(o) + j * 8) : (ulong)0; } public int VectorOfWeakReferencesLength { get { int o = __p.__offset(78); return o != 0 ? __p.__vector_len(o) : 0; } } public ArraySegment? GetVectorOfWeakReferencesBytes() { return __p.__vector_as_arraysegment(78); } + public ulong[] GetVectorOfWeakReferencesArray() { return __p.__vector_as_array(78); } public bool MutateVectorOfWeakReferences(int j, ulong vector_of_weak_references) { int o = __p.__offset(78); if (o != 0) { __p.bb.PutUlong(__p.__vector(o) + j * 8, vector_of_weak_references); return true; } else { return false; } } public Referrable? VectorOfStrongReferrables(int j) { int o = __p.__offset(80); return o != 0 ? (Referrable?)(new Referrable()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; } public int VectorOfStrongReferrablesLength { get { int o = __p.__offset(80); return o != 0 ? __p.__vector_len(o) : 0; } } @@ -115,12 +123,14 @@ public struct Monster : IFlatbufferObject public ulong VectorOfCoOwningReferences(int j) { int o = __p.__offset(84); return o != 0 ? __p.bb.GetUlong(__p.__vector(o) + j * 8) : (ulong)0; } public int VectorOfCoOwningReferencesLength { get { int o = __p.__offset(84); return o != 0 ? __p.__vector_len(o) : 0; } } public ArraySegment? GetVectorOfCoOwningReferencesBytes() { return __p.__vector_as_arraysegment(84); } + public ulong[] GetVectorOfCoOwningReferencesArray() { return __p.__vector_as_array(84); } public bool MutateVectorOfCoOwningReferences(int j, ulong vector_of_co_owning_references) { int o = __p.__offset(84); if (o != 0) { __p.bb.PutUlong(__p.__vector(o) + j * 8, vector_of_co_owning_references); return true; } else { return false; } } public ulong NonOwningReference { get { int o = __p.__offset(86); return o != 0 ? __p.bb.GetUlong(o + __p.bb_pos) : (ulong)0; } } public bool MutateNonOwningReference(ulong non_owning_reference) { int o = __p.__offset(86); if (o != 0) { __p.bb.PutUlong(o + __p.bb_pos, non_owning_reference); return true; } else { return false; } } public ulong VectorOfNonOwningReferences(int j) { int o = __p.__offset(88); return o != 0 ? __p.bb.GetUlong(__p.__vector(o) + j * 8) : (ulong)0; } public int VectorOfNonOwningReferencesLength { get { int o = __p.__offset(88); return o != 0 ? __p.__vector_len(o) : 0; } } public ArraySegment? GetVectorOfNonOwningReferencesBytes() { return __p.__vector_as_arraysegment(88); } + public ulong[] GetVectorOfNonOwningReferencesArray() { return __p.__vector_as_array(88); } public bool MutateVectorOfNonOwningReferences(int j, ulong vector_of_non_owning_references) { int o = __p.__offset(88); if (o != 0) { __p.bb.PutUlong(__p.__vector(o) + j * 8, vector_of_non_owning_references); return true; } else { return false; } } public static void StartMonster(FlatBufferBuilder builder) { builder.StartObject(43); } @@ -130,6 +140,7 @@ public struct Monster : IFlatbufferObject public static void AddName(FlatBufferBuilder builder, StringOffset nameOffset) { builder.AddOffset(3, nameOffset.Value, 0); } 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 void StartInventoryVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); } public static void AddColor(FlatBufferBuilder builder, Color color) { builder.AddSbyte(6, (sbyte)color, 8); } public static void AddTestType(FlatBufferBuilder builder, Any testType) { builder.AddByte(7, (byte)testType, 0); } @@ -138,13 +149,16 @@ public struct Monster : IFlatbufferObject public static void StartTest4Vector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 2); } 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 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 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 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); } @@ -158,44 +172,54 @@ public struct Monster : IFlatbufferObject public static void AddTesthashu64Fnv1a(FlatBufferBuilder builder, ulong testhashu64Fnv1a) { builder.AddUlong(23, testhashu64Fnv1a, 0); } 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 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); } public static void AddTestf3(FlatBufferBuilder builder, float testf3) { builder.AddFloat(27, testf3, 0.0f); } 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 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 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 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 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 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 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 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 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 void StartVectorOfNonOwningReferencesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); } public static Offset EndMonster(FlatBufferBuilder builder) { int o = builder.EndObject(); diff --git a/tests/MyGame/Example/Stat.cs b/tests/MyGame/Example/Stat.cs index e1fd572ed..9d78da5ae 100644 --- a/tests/MyGame/Example/Stat.cs +++ b/tests/MyGame/Example/Stat.cs @@ -19,6 +19,7 @@ public struct Stat : IFlatbufferObject public string Id { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } } public ArraySegment? GetIdBytes() { return __p.__vector_as_arraysegment(4); } + public byte[] GetIdArray() { return __p.__vector_as_array(4); } public long Val { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } } public bool MutateVal(long val) { int o = __p.__offset(6); if (o != 0) { __p.bb.PutLong(o + __p.bb_pos, val); return true; } else { return false; } } public ushort Count { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetUshort(o + __p.bb_pos) : (ushort)0; } } diff --git a/tests/MyGame/Example/TypeAliases.cs b/tests/MyGame/Example/TypeAliases.cs index f03c142ba..c4d87243b 100644 --- a/tests/MyGame/Example/TypeAliases.cs +++ b/tests/MyGame/Example/TypeAliases.cs @@ -40,10 +40,12 @@ public struct TypeAliases : IFlatbufferObject public sbyte V8(int j) { int o = __p.__offset(24); return o != 0 ? __p.bb.GetSbyte(__p.__vector(o) + j * 1) : (sbyte)0; } public int V8Length { get { int o = __p.__offset(24); return o != 0 ? __p.__vector_len(o) : 0; } } public ArraySegment? GetV8Bytes() { return __p.__vector_as_arraysegment(24); } + public sbyte[] GetV8Array() { return __p.__vector_as_array(24); } public bool MutateV8(int j, sbyte v8) { int o = __p.__offset(24); if (o != 0) { __p.bb.PutSbyte(__p.__vector(o) + j * 1, v8); return true; } else { return false; } } public double Vf64(int j) { int o = __p.__offset(26); return o != 0 ? __p.bb.GetDouble(__p.__vector(o) + j * 8) : (double)0; } public int Vf64Length { get { int o = __p.__offset(26); return o != 0 ? __p.__vector_len(o) : 0; } } public ArraySegment? GetVf64Bytes() { return __p.__vector_as_arraysegment(26); } + public double[] GetVf64Array() { return __p.__vector_as_array(26); } public bool MutateVf64(int j, double vf64) { int o = __p.__offset(26); if (o != 0) { __p.bb.PutDouble(__p.__vector(o) + j * 8, vf64); return true; } else { return false; } } public static Offset CreateTypeAliases(FlatBufferBuilder builder, @@ -88,9 +90,11 @@ public struct TypeAliases : IFlatbufferObject public static void AddF64(FlatBufferBuilder builder, double f64) { builder.AddDouble(9, f64, 0.0); } 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 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 void StartVf64Vector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); } public static Offset EndTypeAliases(FlatBufferBuilder builder) { int o = builder.EndObject(); diff --git a/tests/monster_test.bfbs b/tests/monster_test.bfbs index a6b87d4a471054fbd03553e5736dccdacdba2bbc..bb4121c2a414249c6441929ac8e960234991a665 100644 GIT binary patch literal 6432 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 literal 6352 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 diff --git a/tests/namespace_test/namespace_test2_generated.ts b/tests/namespace_test/namespace_test2_generated.ts index 18f1d6e87..1034ef2bc 100644 --- a/tests/namespace_test/namespace_test2_generated.ts +++ b/tests/namespace_test/namespace_test2_generated.ts @@ -1,6 +1,6 @@ // automatically generated by the FlatBuffers compiler, do not modify -import * as NS9459827973991502386 from "./namespace_test1_generated"; +import * as NS11563891686210618450 from "./namespace_test1_generated"; /** * @constructor */ @@ -39,24 +39,24 @@ static getRootAsTableInFirstNS(bb:flatbuffers.ByteBuffer, obj?:TableInFirstNS):T * @param {NamespaceA.NamespaceB.TableInNestedNS=} obj * @returns {NamespaceA.NamespaceB.TableInNestedNS|null} */ -fooTable(obj?:NS9459827973991502386.NamespaceA.NamespaceB.TableInNestedNS):NS9459827973991502386.NamespaceA.NamespaceB.TableInNestedNS|null { +fooTable(obj?:NS11563891686210618450.NamespaceA.NamespaceB.TableInNestedNS):NS11563891686210618450.NamespaceA.NamespaceB.TableInNestedNS|null { var offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new NS9459827973991502386.NamespaceA.NamespaceB.TableInNestedNS).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; + return offset ? (obj || new NS11563891686210618450.NamespaceA.NamespaceB.TableInNestedNS).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; }; /** * @returns {NamespaceA.NamespaceB.EnumInNestedNS} */ -fooEnum():NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS { +fooEnum():NS11563891686210618450.NamespaceA.NamespaceB.EnumInNestedNS { var offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? /** @type {NamespaceA.NamespaceB.EnumInNestedNS} */ (this.bb!.readInt8(this.bb_pos + offset)) : NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS.A; + return offset ? /** @type {NamespaceA.NamespaceB.EnumInNestedNS} */ (this.bb!.readInt8(this.bb_pos + offset)) : NS11563891686210618450.NamespaceA.NamespaceB.EnumInNestedNS.A; }; /** * @param {NamespaceA.NamespaceB.EnumInNestedNS} value * @returns {boolean} */ -mutate_foo_enum(value:NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS):boolean { +mutate_foo_enum(value:NS11563891686210618450.NamespaceA.NamespaceB.EnumInNestedNS):boolean { var offset = this.bb!.__offset(this.bb_pos, 6); if (offset === 0) { @@ -71,9 +71,9 @@ mutate_foo_enum(value:NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS * @param {NamespaceA.NamespaceB.StructInNestedNS=} obj * @returns {NamespaceA.NamespaceB.StructInNestedNS|null} */ -fooStruct(obj?:NS9459827973991502386.NamespaceA.NamespaceB.StructInNestedNS):NS9459827973991502386.NamespaceA.NamespaceB.StructInNestedNS|null { +fooStruct(obj?:NS11563891686210618450.NamespaceA.NamespaceB.StructInNestedNS):NS11563891686210618450.NamespaceA.NamespaceB.StructInNestedNS|null { var offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? (obj || new NS9459827973991502386.NamespaceA.NamespaceB.StructInNestedNS).__init(this.bb_pos + offset, this.bb!) : null; + return offset ? (obj || new NS11563891686210618450.NamespaceA.NamespaceB.StructInNestedNS).__init(this.bb_pos + offset, this.bb!) : null; }; /** @@ -95,8 +95,8 @@ static addFooTable(builder:flatbuffers.Builder, fooTableOffset:flatbuffers.Offse * @param {flatbuffers.Builder} builder * @param {NamespaceA.NamespaceB.EnumInNestedNS} fooEnum */ -static addFooEnum(builder:flatbuffers.Builder, fooEnum:NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS) { - builder.addFieldInt8(1, fooEnum, NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS.A); +static addFooEnum(builder:flatbuffers.Builder, fooEnum:NS11563891686210618450.NamespaceA.NamespaceB.EnumInNestedNS) { + builder.addFieldInt8(1, fooEnum, NS11563891686210618450.NamespaceA.NamespaceB.EnumInNestedNS.A); }; /**